1//===- SPIRVInstructionSelector.cpp ------------------------------*- 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 targeting of the InstructionSelector class for
10// SPIRV.
11// TODO: This should be generated by TableGen.
12//
13//===----------------------------------------------------------------------===//
14
15#include "MCTargetDesc/SPIRVBaseInfo.h"
16#include "MCTargetDesc/SPIRVMCTargetDesc.h"
17#include "SPIRV.h"
18#include "SPIRVGlobalRegistry.h"
19#include "SPIRVInstrInfo.h"
20#include "SPIRVRegisterInfo.h"
21#include "SPIRVTargetMachine.h"
22#include "SPIRVTypeInst.h"
23#include "SPIRVUtils.h"
24#include "llvm/ADT/APFloat.h"
25#include "llvm/ADT/STLExtras.h"
26#include "llvm/ADT/STLFunctionalExtras.h"
27#include "llvm/ADT/SmallSet.h"
28#include "llvm/ADT/StringExtras.h"
29#include "llvm/CodeGen/GlobalISel/GIMatchTableExecutorImpl.h"
30#include "llvm/CodeGen/GlobalISel/GenericMachineInstrs.h"
31#include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
32#include "llvm/CodeGen/MachineInstrBuilder.h"
33#include "llvm/CodeGen/MachineRegisterInfo.h"
34#include "llvm/CodeGen/Register.h"
35#include "llvm/CodeGen/TargetOpcodes.h"
36#include "llvm/IR/DiagnosticInfo.h"
37#include "llvm/IR/IntrinsicsSPIRV.h"
38#include "llvm/Support/Debug.h"
39#include "llvm/Support/ErrorHandling.h"
40#include <functional>
41#include <optional>
42
43#define DEBUG_TYPE "spirv-isel"
44
45using namespace llvm;
46namespace CL = SPIRV::OpenCLExtInst;
47namespace GL = SPIRV::GLSLExtInst;
48
49using ExtInstList =
50 std::vector<std::pair<SPIRV::InstructionSet::InstructionSet, uint32_t>>;
51
52namespace {
53
54struct ImageOperands {
55 std::optional<Register> Bias;
56 std::optional<Register> Offset;
57 std::optional<Register> MinLod;
58 std::optional<Register> GradX;
59 std::optional<Register> GradY;
60 std::optional<Register> Lod;
61 std::optional<Register> Compare;
62};
63
64llvm::SPIRV::SelectionControl::SelectionControl
65getSelectionOperandForImm(int Imm) {
66 if (Imm == 2)
67 return SPIRV::SelectionControl::Flatten;
68 if (Imm == 1)
69 return SPIRV::SelectionControl::DontFlatten;
70 if (Imm == 0)
71 return SPIRV::SelectionControl::None;
72 llvm_unreachable("Invalid immediate");
73}
74
75#define GET_GLOBALISEL_PREDICATE_BITSET
76#include "SPIRVGenGlobalISel.inc"
77#undef GET_GLOBALISEL_PREDICATE_BITSET
78
79class SPIRVInstructionSelector : public InstructionSelector {
80 const SPIRVSubtarget &STI;
81 const SPIRVInstrInfo &TII;
82 const SPIRVRegisterInfo &TRI;
83 const RegisterBankInfo &RBI;
84 SPIRVGlobalRegistry &GR;
85 MachineRegisterInfo *MRI;
86 MachineFunction *HasVRegsReset = nullptr;
87
88 /// We need to keep track of the number we give to anonymous global values to
89 /// generate the same name every time when this is needed.
90 mutable DenseMap<const GlobalValue *, unsigned> UnnamedGlobalIDs;
91 SmallPtrSet<MachineInstr *, 8> DeadMIs;
92
93public:
94 SPIRVInstructionSelector(const SPIRVTargetMachine &TM,
95 const SPIRVSubtarget &ST,
96 const RegisterBankInfo &RBI);
97 void setupMF(MachineFunction &MF, GISelValueTracking *VT,
98 CodeGenCoverage *CoverageInfo, ProfileSummaryInfo *PSI,
99 BlockFrequencyInfo *BFI) override;
100 // Common selection code. Instruction-specific selection occurs in spvSelect.
101 bool select(MachineInstr &I) override;
102 static const char *getName() { return DEBUG_TYPE; }
103
104#define GET_GLOBALISEL_PREDICATES_DECL
105#include "SPIRVGenGlobalISel.inc"
106#undef GET_GLOBALISEL_PREDICATES_DECL
107
108#define GET_GLOBALISEL_TEMPORARIES_DECL
109#include "SPIRVGenGlobalISel.inc"
110#undef GET_GLOBALISEL_TEMPORARIES_DECL
111
112private:
113 void resetVRegsType(MachineFunction &MF);
114 void removeDeadInstruction(MachineInstr &MI) const;
115 void removeOpNamesForDeadMI(MachineInstr &MI) const;
116
117 // tblgen-erated 'select' implementation, used as the initial selector for
118 // the patterns that don't require complex C++.
119 bool selectImpl(MachineInstr &I, CodeGenCoverage &CoverageInfo) const;
120
121 // All instruction-specific selection that didn't happen in "select()".
122 // Is basically a large Switch/Case delegating to all other select method.
123 bool spvSelect(Register ResVReg, SPIRVTypeInst ResType,
124 MachineInstr &I) const;
125
126 bool selectFirstBitHigh(Register ResVReg, SPIRVTypeInst ResType,
127 MachineInstr &I, bool IsSigned) const;
128
129 bool selectFirstBitLow(Register ResVReg, SPIRVTypeInst ResType,
130 MachineInstr &I) const;
131
132 bool selectFirstBitSet16(Register ResVReg, SPIRVTypeInst ResType,
133 MachineInstr &I, unsigned ExtendOpcode,
134 unsigned BitSetOpcode) const;
135
136 bool selectFirstBitSet32(Register ResVReg, SPIRVTypeInst ResType,
137 MachineInstr &I, Register SrcReg,
138 unsigned BitSetOpcode) const;
139
140 bool selectFirstBitSet64(Register ResVReg, SPIRVTypeInst ResType,
141 MachineInstr &I, Register SrcReg,
142 unsigned BitSetOpcode, bool SwapPrimarySide) const;
143
144 bool selectGlobalValue(Register ResVReg, MachineInstr &I,
145 const MachineInstr *Init = nullptr) const;
146
147 bool selectOpWithSrcs(Register ResVReg, SPIRVTypeInst ResType,
148 MachineInstr &I, ArrayRef<Register> SrcRegs,
149 unsigned Opcode) const;
150
151 bool selectUnOp(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
152 unsigned Opcode) const;
153
154 bool selectBitcast(Register ResVReg, SPIRVTypeInst ResType,
155 MachineInstr &I) const;
156
157 bool selectLoad(Register ResVReg, SPIRVTypeInst ResType,
158 MachineInstr &I) const;
159 bool selectAtomicLoad(Register ResVReg, SPIRVTypeInst ResType,
160 MachineInstr &I) const;
161 bool selectStore(MachineInstr &I) const;
162 bool selectAtomicStore(MachineInstr &I) const;
163
164 bool selectStackSave(Register ResVReg, SPIRVTypeInst ResType,
165 MachineInstr &I) const;
166 bool selectStackRestore(MachineInstr &I) const;
167
168 bool selectMemOperation(Register ResVReg, MachineInstr &I) const;
169 Register getOrCreateMemSetGlobal(MachineInstr &I) const;
170 bool selectCopyMemory(MachineInstr &I, Register SrcReg) const;
171
172 bool selectAtomicRMW(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
173 unsigned NewOpcode, unsigned NegateOpcode = 0) const;
174
175 // Creates an integer-typed register with bitwidth equal to pointer size.
176 Register createPtrSizedIntReg(MachineIRBuilder &MIRBuilder) const;
177 // Emit an OpConvertPtrToU that converts the pointer value in \p PtrVal into
178 // an integer of equal bitwidth, returning the register holding the result.
179 Register convertPtrToInt(Register PtrVal, MachineIRBuilder &MIRBuilder) const;
180 // Emit an OpBitcast that reinterprets the pointer \p Ptr as a pointer to an
181 // integer of pointer size in storage class \p SC, returning the result.
182 Register castPtrToPtrToInt(Register Ptr, SPIRV::StorageClass::StorageClass SC,
183 MachineIRBuilder &MIRBuilder) const;
184 // Handle atomic loads, stores and exchanges of pointer types by casting
185 // to/from integer types as needed.
186 bool selectAtomicPtrValue(
187 Register ResVReg, SPIRVTypeInst ResType, MachineIRBuilder &MIRBuilder,
188 function_ref<Register(SPIRVTypeInst IntType)> EmitAtomic) const;
189
190 bool selectAtomicCmpXchg(Register ResVReg, SPIRVTypeInst ResType,
191 MachineInstr &I) const;
192
193 bool selectFence(MachineInstr &I) const;
194
195 bool selectAddrSpaceCast(Register ResVReg, SPIRVTypeInst ResType,
196 MachineInstr &I) const;
197
198 bool selectPtrMask(Register ResVReg, SPIRVTypeInst ResType,
199 MachineInstr &I) const;
200
201 bool selectAnyOrAll(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
202 unsigned OpType) const;
203
204 bool selectAll(Register ResVReg, SPIRVTypeInst ResType,
205 MachineInstr &I) const;
206
207 bool selectAny(Register ResVReg, SPIRVTypeInst ResType,
208 MachineInstr &I) const;
209
210 bool selectBitreverse(Register ResVReg, SPIRVTypeInst ResType,
211 MachineInstr &I) const;
212
213 bool selectBitreverseViaI32(Register ResVReg, SPIRVTypeInst ResType,
214 MachineInstr &I, Register Op) const;
215
216 bool selectBitreverse64(Register ResVReg, SPIRVTypeInst ResType,
217 MachineInstr &I, Register SrcReg) const;
218
219 bool selectBitreverseNative(Register ResVReg, SPIRVTypeInst ResType,
220 MachineInstr &I, Register Op) const;
221
222 bool selectBuildVector(Register ResVReg, SPIRVTypeInst ResType,
223 MachineInstr &I) const;
224 bool selectSplatVector(Register ResVReg, SPIRVTypeInst ResType,
225 MachineInstr &I) const;
226 bool selectConcatVectors(Register ResVReg, SPIRVTypeInst ResType,
227 MachineInstr &I) const;
228
229 bool selectCmp(Register ResVReg, SPIRVTypeInst ResType,
230 unsigned comparisonOpcode, MachineInstr &I) const;
231 bool selectDiscard(Register ResVReg, SPIRVTypeInst ResType,
232 MachineInstr &I) const;
233
234 bool selectICmp(Register ResVReg, SPIRVTypeInst ResType,
235 MachineInstr &I) const;
236 bool selectFCmp(Register ResVReg, SPIRVTypeInst ResType,
237 MachineInstr &I) const;
238
239 bool selectSign(Register ResVReg, SPIRVTypeInst ResType,
240 MachineInstr &I) const;
241
242 bool selectFloatDot(Register ResVReg, SPIRVTypeInst ResType,
243 MachineInstr &I) const;
244
245 bool selectOverflowArith(Register ResVReg, SPIRVTypeInst ResType,
246 MachineInstr &I, unsigned Opcode) const;
247 bool selectDebugTrap(Register ResVReg, SPIRVTypeInst ResType,
248 MachineInstr &I) const;
249 bool selectPrefetch(MachineInstr &I) const;
250
251 bool selectIntegerDot(Register ResVReg, SPIRVTypeInst ResType,
252 MachineInstr &I, bool Signed) const;
253
254 bool selectIntegerDotExpansion(Register ResVReg, SPIRVTypeInst ResType,
255 MachineInstr &I) const;
256
257 bool selectOpIsInf(Register ResVReg, SPIRVTypeInst ResType,
258 MachineInstr &I) const;
259
260 bool selectOpIsNan(Register ResVReg, SPIRVTypeInst ResType,
261 MachineInstr &I) const;
262
263 bool selectOpIsFinite(Register ResVReg, SPIRVTypeInst ResType,
264 MachineInstr &I) const;
265
266 bool selectOpIsNormal(Register ResVReg, SPIRVTypeInst ResType,
267 MachineInstr &I) const;
268
269 bool selectPopCount(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
270 unsigned Opcode) const;
271
272 bool selectPopCount16(Register ResVReg, SPIRVTypeInst ResType,
273 MachineInstr &I, unsigned ExtOpcode,
274 unsigned Opcode) const;
275
276 bool selectPopCount32(Register ResVReg, SPIRVTypeInst ResType,
277 MachineInstr &I, Register SrcReg,
278 unsigned Opcode) const;
279
280 bool selectPopCount64(Register ResVReg, SPIRVTypeInst ResType,
281 MachineInstr &I, Register SrcReg,
282 unsigned Opcode) const;
283
284 template <bool Signed>
285 bool selectDot4AddPacked(Register ResVReg, SPIRVTypeInst ResType,
286 MachineInstr &I) const;
287 template <bool Signed>
288 bool selectDot4AddPackedExpansion(Register ResVReg, SPIRVTypeInst ResType,
289 MachineInstr &I) const;
290
291 bool selectWavePrefixBitCount(Register ResVReg, SPIRVTypeInst ResType,
292 MachineInstr &I) const;
293
294 template <typename PickOpcodeFn>
295 bool selectWaveReduce(Register ResVReg, SPIRVTypeInst ResType,
296 MachineInstr &I, bool IsUnsigned,
297 PickOpcodeFn &&PickOpcode) const;
298
299 bool selectWaveReduceOp(Register ResVReg, SPIRVTypeInst ResType,
300 MachineInstr &I, unsigned Opcode) const;
301
302 bool selectWaveReduceMax(Register ResVReg, SPIRVTypeInst ResType,
303 MachineInstr &I, bool IsUnsigned) const;
304
305 bool selectWaveReduceMin(Register ResVReg, SPIRVTypeInst ResType,
306 MachineInstr &I, bool IsUnsigned) const;
307
308 bool selectWaveReduceSum(Register ResVReg, SPIRVTypeInst ResType,
309 MachineInstr &I) const;
310
311 bool selectWaveReduceProduct(Register ResVReg, const SPIRVTypeInst ResType,
312 MachineInstr &I) const;
313
314 template <typename PickOpcodeFn>
315 bool selectWaveExclusiveScan(Register ResVReg, SPIRVTypeInst ResType,
316 MachineInstr &I, bool IsUnsigned,
317 PickOpcodeFn &&PickOpcode) const;
318
319 bool selectWaveExclusiveScanSum(Register ResVReg, SPIRVTypeInst ResType,
320 MachineInstr &I) const;
321
322 bool selectWaveExclusiveScanProduct(Register ResVReg, SPIRVTypeInst ResType,
323 MachineInstr &I) const;
324
325 bool selectWaveMultiPrefixOp(Register ResVReg, SPIRVTypeInst ResType,
326 MachineInstr &I, unsigned Opcode,
327 StringRef BuiltinName) const;
328
329 bool selectQuadSwap(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
330 unsigned Direction) const;
331
332 bool selectQuadAll(Register ResVReg, SPIRVTypeInst ResType,
333 MachineInstr &I) const;
334
335 bool selectConst(Register ResVReg, SPIRVTypeInst ResType,
336 MachineInstr &I) const;
337
338 bool selectSelect(Register ResVReg, SPIRVTypeInst ResType,
339 MachineInstr &I) const;
340 bool selectBoolToInt(Register ResVReg, SPIRVTypeInst ResType,
341 Register BooleanVReg, MachineInstr &InsertAt,
342 bool IsSigned) const;
343 bool selectIToF(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
344 bool IsSigned, unsigned Opcode) const;
345 bool selectExt(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
346 bool IsSigned) const;
347
348 bool selectTrunc(Register ResVReg, SPIRVTypeInst ResType,
349 MachineInstr &I) const;
350
351 bool selectSUCmp(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
352 bool IsSigned) const;
353
354 bool selectIntToBool(Register IntReg, Register ResVReg, MachineInstr &I,
355 SPIRVTypeInst intTy, SPIRVTypeInst boolTy) const;
356
357 bool selectOpUndef(Register ResVReg, SPIRVTypeInst ResType,
358 MachineInstr &I) const;
359 bool selectFreeze(Register ResVReg, SPIRVTypeInst ResType,
360 MachineInstr &I) const;
361 bool selectIntrinsic(Register ResVReg, SPIRVTypeInst ResType,
362 MachineInstr &I) const;
363 bool selectExtractVal(Register ResVReg, SPIRVTypeInst ResType,
364 MachineInstr &I) const;
365 bool selectInsertVal(Register ResVReg, SPIRVTypeInst ResType,
366 MachineInstr &I) const;
367 bool selectExtractElt(Register ResVReg, SPIRVTypeInst ResType,
368 MachineInstr &I) const;
369 bool selectInsertElt(Register ResVReg, SPIRVTypeInst ResType,
370 MachineInstr &I) const;
371 bool selectGEP(Register ResVReg, SPIRVTypeInst ResType,
372 MachineInstr &I) const;
373
374 bool selectMaskedGather(Register ResVReg, SPIRVTypeInst ResType,
375 MachineInstr &I) const;
376 bool selectMaskedScatter(MachineInstr &I) const;
377
378 bool diagnoseUnsupported(const MachineInstr &I, const Twine &Msg) const;
379
380 bool selectAbort(MachineInstr &I) const;
381 bool selectTrap(MachineInstr &I) const;
382 bool selectFrameIndex(Register ResVReg, SPIRVTypeInst ResType,
383 MachineInstr &I) const;
384 bool selectAllocaArray(Register ResVReg, SPIRVTypeInst ResType,
385 MachineInstr &I) const;
386
387 bool selectBranch(MachineInstr &I) const;
388 bool selectBranchCond(MachineInstr &I) const;
389
390 bool selectPhi(Register ResVReg, MachineInstr &I) const;
391
392 bool selectExtInst(Register ResVReg, SPIRVTypeInst RestType, MachineInstr &I,
393 GL::GLSLExtInst GLInst, bool setMIFlags = true,
394 bool useMISrc = true,
395 ArrayRef<Register> SrcRegs = {}) const;
396 bool selectExtInst(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
397 CL::OpenCLExtInst CLInst, bool setMIFlags = true,
398 bool useMISrc = true,
399 ArrayRef<Register> SrcRegs = {}) const;
400 bool selectExtInst(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
401 CL::OpenCLExtInst CLInst, GL::GLSLExtInst GLInst,
402 bool setMIFlags = true, bool useMISrc = true,
403 ArrayRef<Register> SrcRegs = {}) const;
404 bool selectExtInst(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
405 const ExtInstList &ExtInsts, bool setMIFlags = true,
406 bool useMISrc = true,
407 ArrayRef<Register> SrcRegs = {}) const;
408
409 bool selectLog10(Register ResVReg, SPIRVTypeInst ResType,
410 MachineInstr &I) const;
411
412 bool selectFpowi(Register ResVReg, SPIRVTypeInst ResType,
413 MachineInstr &I) const;
414
415 bool selectSaturate(Register ResVReg, SPIRVTypeInst ResType,
416 MachineInstr &I) const;
417
418 bool selectWaveOpInst(Register ResVReg, SPIRVTypeInst ResType,
419 MachineInstr &I, unsigned Opcode) const;
420
421 bool selectBarrierInst(MachineInstr &I, unsigned Scope, unsigned MemSem,
422 bool WithGroupSync) const;
423
424 bool selectWaveActiveCountBits(Register ResVReg, SPIRVTypeInst ResType,
425 MachineInstr &I) const;
426
427 bool selectWaveActiveAllEqual(Register ResVReg, SPIRVTypeInst ResType,
428 MachineInstr &I) const;
429
430 bool selectUnmergeValues(MachineInstr &I) const;
431
432 bool selectHandleFromBinding(Register &ResVReg, SPIRVTypeInst ResType,
433 MachineInstr &I) const;
434
435 bool selectCounterHandleFromBinding(Register &ResVReg, SPIRVTypeInst ResType,
436 MachineInstr &I) const;
437
438 bool selectReadImageIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
439 MachineInstr &I) const;
440 bool selectGetDimensionsIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
441 MachineInstr &I) const;
442 bool selectGetDimensionsLevelsIntrinsic(Register &ResVReg,
443 SPIRVTypeInst ResType,
444 MachineInstr &I) const;
445 bool selectGetDimensionsMSIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
446 MachineInstr &I) const;
447 bool
448 selectImageQuerySize(Register ImageReg, Register &ResVReg, MachineInstr &I,
449 std::optional<Register> LodReg = std::nullopt) const;
450 bool selectSampleBasicIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
451 MachineInstr &I) const;
452 bool selectCalculateLodIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
453 MachineInstr &I) const;
454 bool selectSampleBiasIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
455 MachineInstr &I) const;
456 bool selectSampleGradIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
457 MachineInstr &I) const;
458 bool selectSampleLevelIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
459 MachineInstr &I) const;
460 bool selectLoadLevelIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
461 MachineInstr &I) const;
462 bool selectSampleCmpIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
463 MachineInstr &I) const;
464 bool selectSampleCmpLevelZeroIntrinsic(Register &ResVReg,
465 SPIRVTypeInst ResType,
466 MachineInstr &I) const;
467 bool selectGatherIntrinsic(Register &ResVReg, SPIRVTypeInst ResType,
468 MachineInstr &I) const;
469 bool selectImageWriteIntrinsic(MachineInstr &I) const;
470 bool selectResourceGetPointer(Register &ResVReg, SPIRVTypeInst ResType,
471 MachineInstr &I) const;
472 bool selectPushConstantGetPointer(Register &ResVReg, SPIRVTypeInst ResType,
473 MachineInstr &I) const;
474 bool selectResourceNonUniformIndex(Register &ResVReg, SPIRVTypeInst ResType,
475 MachineInstr &I) const;
476 bool selectModf(Register ResVReg, SPIRVTypeInst ResType,
477 MachineInstr &I) const;
478 bool selectUpdateCounter(Register &ResVReg, SPIRVTypeInst ResType,
479 MachineInstr &I) const;
480 bool selectFrexp(Register ResVReg, SPIRVTypeInst ResType,
481 MachineInstr &I) const;
482
483 bool selectCopySign(Register ResVReg, SPIRVTypeInst ResType,
484 MachineInstr &I) const;
485
486 bool selectLdexp(Register ResVReg, SPIRVTypeInst ResType,
487 MachineInstr &I) const;
488 bool selectSincos(Register ResVReg, SPIRVTypeInst ResType,
489 MachineInstr &I) const;
490 bool selectExp10(Register ResVReg, SPIRVTypeInst ResType,
491 MachineInstr &I) const;
492 bool selectDerivativeInst(Register ResVReg, SPIRVTypeInst ResType,
493 MachineInstr &I, const unsigned DPdOpCode) const;
494 // Utilities
495 Register buildI32ConstantInEntryBlock(uint32_t Val, MachineInstr &I,
496 SPIRVTypeInst ResType = nullptr) const;
497
498 Register buildZerosVal(SPIRVTypeInst ResType, MachineInstr &I) const;
499 bool isScalarOrVectorIntConstantZero(Register Reg) const;
500 Register buildZerosValF(SPIRVTypeInst ResType, MachineInstr &I) const;
501 Register buildOnesVal(bool AllOnes, SPIRVTypeInst ResType,
502 MachineInstr &I) const;
503 Register buildOnesValF(SPIRVTypeInst ResType, MachineInstr &I) const;
504 Register buildVectorSplat(Register ScalarReg, unsigned NumElts,
505 MachineInstr &I) const;
506
507 bool wrapIntoSpecConstantOp(MachineInstr &I,
508 SmallVector<Register> &CompositeArgs) const;
509
510 SPIRVTypeInst getUcharPtrType(MachineInstr &I,
511 SPIRV::StorageClass::StorageClass SC) const;
512 Register getUcharPtrTypeReg(MachineInstr &I,
513 SPIRV::StorageClass::StorageClass SC) const;
514 MachineInstrBuilder buildSpecConstantOp(MachineInstr &I, Register Dest,
515 Register Src, Register DestType,
516 uint32_t Opcode) const;
517 Register bitcastConstPtrToI8(MachineInstr &I, Register Src) const;
518 MachineInstrBuilder buildConstGenericPtr(MachineInstr &I, Register SrcPtr,
519 SPIRVTypeInst SrcPtrTy) const;
520 Register buildPointerToResource(SPIRVTypeInst ResType,
521 SPIRV::StorageClass::StorageClass SC,
522 uint32_t Set, uint32_t Binding,
523 uint32_t ArraySize, Register IndexReg,
524 StringRef Name,
525 MachineIRBuilder MIRBuilder) const;
526 SPIRVTypeInst widenTypeToVec4(SPIRVTypeInst Type, MachineInstr &I) const;
527 bool extractSubvector(Register &ResVReg, SPIRVTypeInst ResType,
528 Register &ReadReg, MachineInstr &InsertionPoint) const;
529 bool generateImageReadOrFetch(Register &ResVReg, SPIRVTypeInst ResType,
530 Register ImageReg, Register IdxReg,
531 DebugLoc Loc, MachineInstr &Pos,
532 const ImageOperands *ImOps = nullptr) const;
533 bool generateSampleImage(Register ResVReg, SPIRVTypeInst ResType,
534 Register ImageReg, Register SamplerReg,
535 Register CoordinateReg, const ImageOperands &ImOps,
536 DebugLoc Loc, MachineInstr &I) const;
537 bool BuildCOPY(Register DestReg, Register SrcReg, MachineInstr &I) const;
538 bool loadVec3BuiltinInputID(SPIRV::BuiltIn::BuiltIn BuiltInValue,
539 Register ResVReg, SPIRVTypeInst ResType,
540 MachineInstr &I) const;
541 bool loadBuiltinInputID(SPIRV::BuiltIn::BuiltIn BuiltInValue,
542 Register ResVReg, SPIRVTypeInst ResType,
543 MachineInstr &I) const;
544 bool loadHandleBeforePosition(Register &HandleReg, SPIRVTypeInst ResType,
545 GIntrinsic &HandleDef, MachineInstr &Pos) const;
546 void decorateUsesAsNonUniform(Register &NonUniformReg) const;
547 bool errorIfInstrOutsideShader(MachineInstr &I) const;
548
549 bool
550 handle64BitOverflow(Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
551 Register SrcReg, unsigned int Opcode,
552 std::function<bool(Register, SPIRVTypeInst,
553 MachineInstr &, Register, unsigned)>
554 CallbackFunction) const;
555};
556
557bool sampledTypeIsSignedInteger(const llvm::Type *HandleType) {
558 const TargetExtType *TET = cast<TargetExtType>(Val: HandleType);
559 if (TET->getTargetExtName() == "spirv.Image") {
560 return false;
561 }
562 assert(TET->getTargetExtName() == "spirv.SignedImage");
563 return TET->getTypeParameter(i: 0)->isIntegerTy();
564}
565} // end anonymous namespace
566
567#define GET_GLOBALISEL_IMPL
568#include "SPIRVGenGlobalISel.inc"
569#undef GET_GLOBALISEL_IMPL
570
571SPIRVInstructionSelector::SPIRVInstructionSelector(const SPIRVTargetMachine &TM,
572 const SPIRVSubtarget &ST,
573 const RegisterBankInfo &RBI)
574 : InstructionSelector(), STI(ST), TII(*ST.getInstrInfo()),
575 TRI(*ST.getRegisterInfo()), RBI(RBI), GR(*ST.getSPIRVGlobalRegistry()),
576 MRI(nullptr),
577#define GET_GLOBALISEL_PREDICATES_INIT
578#include "SPIRVGenGlobalISel.inc"
579#undef GET_GLOBALISEL_PREDICATES_INIT
580#define GET_GLOBALISEL_TEMPORARIES_INIT
581#include "SPIRVGenGlobalISel.inc"
582#undef GET_GLOBALISEL_TEMPORARIES_INIT
583{
584}
585
586void SPIRVInstructionSelector::setupMF(MachineFunction &MF,
587 GISelValueTracking *VT,
588 CodeGenCoverage *CoverageInfo,
589 ProfileSummaryInfo *PSI,
590 BlockFrequencyInfo *BFI) {
591 MRI = &MF.getRegInfo();
592 GR.setCurrentFunc(MF);
593 InstructionSelector::setupMF(mf&: MF, vt: VT, covinfo: CoverageInfo, psi: PSI, bfi: BFI);
594}
595
596// Ensure that register classes correspond to pattern matching rules.
597void SPIRVInstructionSelector::resetVRegsType(MachineFunction &MF) {
598 if (HasVRegsReset == &MF)
599 return;
600 HasVRegsReset = &MF;
601
602 MachineRegisterInfo &MRI = MF.getRegInfo();
603 for (unsigned I = 0, E = MRI.getNumVirtRegs(); I != E; ++I) {
604 Register Reg = Register::index2VirtReg(Index: I);
605 LLT RegType = MRI.getType(Reg);
606 LLT ScalarTy =
607 RegType.isFloatOrFloatVector() ? LLT::float64() : LLT::integer(SizeInBits: 64);
608 if (RegType.isScalar())
609 MRI.setType(VReg: Reg, Ty: ScalarTy);
610 else if (RegType.isPointer())
611 MRI.setType(VReg: Reg, Ty: LLT::pointer(AddressSpace: 0, SizeInBits: 64));
612 else if (RegType.isVector())
613 MRI.setType(VReg: Reg, Ty: LLT::fixed_vector(NumElements: 2, ScalarTy));
614 }
615 for (const auto &MBB : MF) {
616 for (const auto &MI : MBB) {
617 if (isPreISelGenericOpcode(Opcode: MI.getOpcode()))
618 GR.erase(MI: &MI);
619 if (MI.getOpcode() != SPIRV::ASSIGN_TYPE)
620 continue;
621
622 Register DstReg = MI.getOperand(i: 0).getReg();
623 LLT DstType = MRI.getType(Reg: DstReg);
624 Register SrcReg = MI.getOperand(i: 1).getReg();
625 LLT SrcType = MRI.getType(Reg: SrcReg);
626 if (DstType != SrcType)
627 MRI.setType(VReg: DstReg, Ty: MRI.getType(Reg: SrcReg));
628
629 const TargetRegisterClass *DstRC = MRI.getRegClassOrNull(Reg: DstReg);
630 const TargetRegisterClass *SrcRC = MRI.getRegClassOrNull(Reg: SrcReg);
631 if (DstRC != SrcRC && SrcRC)
632 MRI.setRegClass(Reg: DstReg, RC: SrcRC);
633 }
634 }
635}
636
637// Return true if the MachineInstr represents a constant register
638static bool isConstReg(MachineRegisterInfo *MRI, MachineInstr *OpDef) {
639
640 SmallVector<MachineInstr *> Stack = {OpDef};
641 SmallPtrSet<MachineInstr *, 4> Visited;
642
643 while (!Stack.empty()) {
644 MachineInstr *MI = Stack.pop_back_val();
645 MI = passCopy(Def: MI, MRI);
646 if (!Visited.insert(Ptr: MI).second)
647 continue;
648 switch (MI->getOpcode()) {
649 case TargetOpcode::G_INTRINSIC:
650 case TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS:
651 case TargetOpcode::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS: {
652 GIntrinsic *GIntr = cast<GIntrinsic>(Val: MI);
653 unsigned IntrID = GIntr->getIntrinsicID();
654 if (IntrID != Intrinsic::spv_const_composite &&
655 IntrID != Intrinsic::spv_undef && IntrID != Intrinsic::spv_poison)
656 return false;
657 continue;
658 }
659 case TargetOpcode::G_BUILD_VECTOR:
660 case TargetOpcode::G_SPLAT_VECTOR:
661 for (unsigned i = OpDef->getNumExplicitDefs();
662 i < OpDef->getNumOperands(); i++) {
663 if (!OpDef->getOperand(i).isReg())
664 continue;
665 MachineInstr *OpNestedDef =
666 MRI->getVRegDef(Reg: OpDef->getOperand(i).getReg());
667 Stack.push_back(Elt: OpNestedDef);
668 }
669 continue;
670 case TargetOpcode::G_CONSTANT:
671 case TargetOpcode::G_FCONSTANT:
672 case TargetOpcode::G_IMPLICIT_DEF:
673 case SPIRV::OpConstantTrue:
674 case SPIRV::OpConstantFalse:
675 case SPIRV::OpConstantI:
676 case SPIRV::OpConstantF:
677 case SPIRV::OpConstantComposite:
678 case SPIRV::OpConstantCompositeContinuedINTEL:
679 case SPIRV::OpConstantSampler:
680 case SPIRV::OpConstantNull:
681 case SPIRV::OpUndef:
682 case SPIRV::OpPoisonKHR:
683 case SPIRV::OpConstantFunctionPointerINTEL:
684 continue;
685 default:
686 return false;
687 }
688 }
689 return true;
690}
691
692// Return true if the virtual register represents a constant
693static bool isConstReg(MachineRegisterInfo *MRI, Register OpReg) {
694 if (MachineInstr *OpDef = MRI->getVRegDef(Reg: OpReg))
695 return isConstReg(MRI, OpDef);
696 return false;
697}
698
699// TODO(168736): We should make this either a flag in tabelgen
700// or reduce our dependence on the global registry, so we can remove this
701// function. It can easily be missed when new intrinsics are added.
702
703// Most SPIR-V intrinsics are considered to have side-effects in their tablegen
704// definition because they are referenced in the global registry. This is a list
705// of intrinsics that have no side effects other than their references in the
706// global registry.
707static bool intrinsicHasSideEffects(Intrinsic::ID ID) {
708 switch (ID) {
709 // This is not an exhaustive list and may need to be updated.
710 case Intrinsic::spv_all:
711 case Intrinsic::spv_alloca:
712 case Intrinsic::spv_any:
713 case Intrinsic::spv_bitcast:
714 case Intrinsic::spv_const_composite:
715 case Intrinsic::spv_degrees:
716 case Intrinsic::spv_distance:
717 case Intrinsic::spv_extractelt:
718 case Intrinsic::spv_extractv:
719 case Intrinsic::spv_faceforward:
720 case Intrinsic::spv_fdot:
721 case Intrinsic::spv_firstbitlow:
722 case Intrinsic::spv_firstbitshigh:
723 case Intrinsic::spv_firstbituhigh:
724 case Intrinsic::spv_frac:
725 case Intrinsic::spv_gep:
726 case Intrinsic::spv_global_offset:
727 case Intrinsic::spv_global_size:
728 case Intrinsic::spv_group_id:
729 case Intrinsic::spv_insertelt:
730 case Intrinsic::spv_insertv:
731 case Intrinsic::spv_isinf:
732 case Intrinsic::spv_isnan:
733 case Intrinsic::spv_isfinite:
734 case Intrinsic::spv_isnormal:
735 case Intrinsic::spv_lerp:
736 case Intrinsic::spv_length:
737 case Intrinsic::spv_normalize:
738 case Intrinsic::spv_num_subgroups:
739 case Intrinsic::spv_num_workgroups:
740 case Intrinsic::spv_ptrcast:
741 case Intrinsic::spv_radians:
742 case Intrinsic::spv_reflect:
743 case Intrinsic::spv_refract:
744 case Intrinsic::spv_resource_getbasepointer:
745 case Intrinsic::spv_resource_getpointer:
746 case Intrinsic::spv_resource_handlefrombinding:
747 case Intrinsic::spv_resource_handlefromimplicitbinding:
748 case Intrinsic::spv_resource_nonuniformindex:
749 case Intrinsic::spv_resource_sample:
750 case Intrinsic::spv_rsqrt:
751 case Intrinsic::spv_saturate:
752 case Intrinsic::spv_sdot:
753 case Intrinsic::spv_sign:
754 case Intrinsic::spv_smoothstep:
755 case Intrinsic::spv_subgroup_id:
756 case Intrinsic::spv_subgroup_local_invocation_id:
757 case Intrinsic::spv_subgroup_max_size:
758 case Intrinsic::spv_subgroup_size:
759 case Intrinsic::spv_thread_id:
760 case Intrinsic::spv_thread_id_in_group:
761 case Intrinsic::spv_udot:
762 case Intrinsic::spv_undef:
763 case Intrinsic::spv_value_md:
764 case Intrinsic::spv_workgroup_size:
765 return false;
766 default:
767 return true;
768 }
769}
770
771// TODO(168736): We should make this either a flag in tabelgen
772// or reduce our dependence on the global registry, so we can remove this
773// function. It can easily be missed when new intrinsics are added.
774static bool isOpcodeWithNoSideEffects(unsigned Opcode) {
775 switch (Opcode) {
776 case SPIRV::OpTypeVoid:
777 case SPIRV::OpTypeBool:
778 case SPIRV::OpTypeInt:
779 case SPIRV::OpTypeFloat:
780 case SPIRV::OpTypeVector:
781 case SPIRV::OpTypeVectorIdEXT:
782 case SPIRV::OpTypeMatrix:
783 case SPIRV::OpTypeImage:
784 case SPIRV::OpTypeSampler:
785 case SPIRV::OpTypeSampledImage:
786 case SPIRV::OpTypeArray:
787 case SPIRV::OpTypeRuntimeArray:
788 case SPIRV::OpTypeStruct:
789 case SPIRV::OpTypeOpaque:
790 case SPIRV::OpTypePointer:
791 case SPIRV::OpTypeFunction:
792 case SPIRV::OpTypeEvent:
793 case SPIRV::OpTypeDeviceEvent:
794 case SPIRV::OpTypeReserveId:
795 case SPIRV::OpTypeQueue:
796 case SPIRV::OpTypePipe:
797 case SPIRV::OpTypeForwardPointer:
798 case SPIRV::OpTypePipeStorage:
799 case SPIRV::OpTypeNamedBarrier:
800 case SPIRV::OpTypeAccelerationStructureNV:
801 case SPIRV::OpTypeCooperativeMatrixNV:
802 case SPIRV::OpTypeCooperativeMatrixKHR:
803 return true;
804 default:
805 return false;
806 }
807}
808
809bool isDead(const MachineInstr &MI, const MachineRegisterInfo &MRI) {
810 // If there are no definitions, then assume there is some other
811 // side-effect that makes this instruction live.
812 if (MI.getNumDefs() == 0)
813 return false;
814
815 for (const auto &MO : MI.all_defs()) {
816 Register Reg = MO.getReg();
817 if (Reg.isPhysical()) {
818 LLVM_DEBUG(dbgs() << "Not dead: def of physical register " << Reg);
819 return false;
820 }
821 for (const auto &UseMI : MRI.use_nodbg_instructions(Reg)) {
822 if (UseMI.getOpcode() != SPIRV::OpName) {
823 LLVM_DEBUG(dbgs() << "Not dead: def " << MO << " has use in " << UseMI);
824 return false;
825 }
826 }
827 }
828
829 if (MI.getOpcode() == TargetOpcode::LOCAL_ESCAPE || MI.isFakeUse() ||
830 MI.isLifetimeMarker()) {
831 LLVM_DEBUG(
832 dbgs()
833 << "Not dead: Opcode is LOCAL_ESCAPE, fake use, or lifetime marker.\n");
834 return false;
835 }
836 if (MI.isPHI()) {
837 LLVM_DEBUG(dbgs() << "Dead: Phi instruction with no uses.\n");
838 return true;
839 }
840
841 // It is possible that the only side effect is that the instruction is
842 // referenced in the global registry. If that is the only side effect, the
843 // intrinsic is dead.
844 if (MI.getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS ||
845 MI.getOpcode() == TargetOpcode::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS) {
846 const auto &Intr = cast<GIntrinsic>(Val: MI);
847 if (!intrinsicHasSideEffects(ID: Intr.getIntrinsicID())) {
848 LLVM_DEBUG(dbgs() << "Dead: Intrinsic with no real side effects.\n");
849 return true;
850 }
851 }
852
853 if (MI.mayStore() || MI.isCall() ||
854 (MI.mayLoad() && MI.hasOrderedMemoryRef()) || MI.isPosition() ||
855 MI.isDebugInstr() || MI.isTerminator() || MI.isJumpTableDebugInfo()) {
856 LLVM_DEBUG(dbgs() << "Not dead: instruction has side effects.\n");
857 return false;
858 }
859
860 if (isPreISelGenericOpcode(Opcode: MI.getOpcode())) {
861 // TODO: Is there a generic way to check if the opcode has side effects?
862 LLVM_DEBUG(dbgs() << "Dead: Generic opcode with no uses.\n");
863 return true;
864 }
865
866 if (isOpcodeWithNoSideEffects(Opcode: MI.getOpcode())) {
867 LLVM_DEBUG(dbgs() << "Dead: known opcode with no side effects\n");
868 return true;
869 }
870
871 return false;
872}
873
874void SPIRVInstructionSelector::removeOpNamesForDeadMI(MachineInstr &MI) const {
875 // Delete the OpName that uses the result if there is one.
876 for (const auto &MO : MI.all_defs()) {
877 Register Reg = MO.getReg();
878 if (Reg.isPhysical())
879 continue;
880 SmallVector<MachineInstr *, 4> UselessOpNames;
881 for (MachineInstr &UseMI : MRI->use_nodbg_instructions(Reg)) {
882 assert(UseMI.getOpcode() == SPIRV::OpName &&
883 "There is still a use of the dead function.");
884 UselessOpNames.push_back(Elt: &UseMI);
885 }
886 for (MachineInstr *OpNameMI : UselessOpNames) {
887 GR.invalidateMachineInstr(MI: OpNameMI);
888 OpNameMI->eraseFromParent();
889 }
890 }
891}
892
893void SPIRVInstructionSelector::removeDeadInstruction(MachineInstr &MI) const {
894 salvageDebugInfo(MRI: *MRI, MI);
895 GR.invalidateMachineInstr(MI: &MI);
896 removeOpNamesForDeadMI(MI);
897 MI.eraseFromParent();
898}
899
900bool SPIRVInstructionSelector::select(MachineInstr &I) {
901 resetVRegsType(MF&: *I.getParent()->getParent());
902
903 assert(I.getParent() && "Instruction should be in a basic block!");
904 assert(I.getParent()->getParent() && "Instruction should be in a function!");
905
906 LLVM_DEBUG(dbgs() << "Checking if instruction is dead: " << I;);
907 if (isDead(MI: I, MRI: *MRI)) {
908 LLVM_DEBUG(dbgs() << "Instruction is dead.\n");
909 removeDeadInstruction(MI&: I);
910 return true;
911 }
912
913 Register Opcode = I.getOpcode();
914 // If it's not a GMIR instruction, we've selected it already.
915 if (!isPreISelGenericOpcode(Opcode)) {
916 if (Opcode == SPIRV::ASSIGN_TYPE) { // These pseudos aren't needed any more.
917 Register DstReg = I.getOperand(i: 0).getReg();
918 Register SrcReg = I.getOperand(i: 1).getReg();
919 auto *Def = MRI->getVRegDef(Reg: SrcReg);
920 if (isTypeFoldingSupported(Opcode: Def->getOpcode()) &&
921 Def->getOpcode() != TargetOpcode::G_CONSTANT &&
922 Def->getOpcode() != TargetOpcode::G_FCONSTANT) {
923 if (Def->getOpcode() == TargetOpcode::G_SELECT) {
924 Register SelectDstReg = Def->getOperand(i: 0).getReg();
925 bool SuccessToSelectSelect [[maybe_unused]] = selectSelect(
926 ResVReg: SelectDstReg, ResType: GR.getSPIRVTypeForVReg(VReg: SelectDstReg), I&: *Def);
927 assert(SuccessToSelectSelect);
928 GR.invalidateMachineInstr(MI: Def);
929 Def->eraseFromParent();
930 MRI->replaceRegWith(FromReg: DstReg, ToReg: SelectDstReg);
931 GR.invalidateMachineInstr(MI: &I);
932 I.eraseFromParent();
933 return true;
934 }
935
936 bool Res = selectImpl(I, CoverageInfo&: *CoverageInfo);
937 LLVM_DEBUG({
938 if (!Res && Def->getOpcode() != TargetOpcode::G_CONSTANT) {
939 dbgs() << "Unexpected pattern in ASSIGN_TYPE.\nInstruction: ";
940 I.print(dbgs());
941 }
942 });
943 assert(Res || Def->getOpcode() == TargetOpcode::G_CONSTANT);
944 if (Res) {
945 if (!isTriviallyDead(MI: *Def, MRI: *MRI) && isDead(MI: *Def, MRI: *MRI))
946 DeadMIs.insert(Ptr: Def);
947 return Res;
948 }
949 }
950 MRI->setRegClass(Reg: SrcReg, RC: MRI->getRegClass(Reg: DstReg));
951 MRI->replaceRegWith(FromReg: SrcReg, ToReg: DstReg);
952 GR.invalidateMachineInstr(MI: &I);
953 I.eraseFromParent();
954 return true;
955 } else if (I.getNumDefs() == 1) {
956 // Make all vregs 64 bits (for SPIR-V IDs).
957 MRI->setType(VReg: I.getOperand(i: 0).getReg(), Ty: LLT::scalar(SizeInBits: 64));
958 }
959 constrainSelectedInstRegOperands(I, TII, TRI, RBI);
960 return true;
961 }
962
963 if (DeadMIs.contains(Ptr: &I)) {
964 // if the instruction has been already made dead by folding it away
965 // erase it
966 LLVM_DEBUG(dbgs() << "Instruction is folded and dead.\n");
967 removeDeadInstruction(MI&: I);
968 DeadMIs.erase(Ptr: &I);
969 return true;
970 }
971
972 if (I.getNumOperands() != I.getNumExplicitOperands()) {
973 LLVM_DEBUG(errs() << "Generic instr has unexpected implicit operands\n");
974 return false;
975 }
976
977 // Common code for getting return reg+type, and removing selected instr
978 // from parent occurs here. Instr-specific selection happens in spvSelect().
979 bool HasDefs = I.getNumDefs() > 0;
980 Register ResVReg = HasDefs ? I.getOperand(i: 0).getReg() : Register(0);
981 SPIRVTypeInst ResType = HasDefs ? GR.getSPIRVTypeForVReg(VReg: ResVReg) : nullptr;
982 assert(!HasDefs || ResType || I.getOpcode() == TargetOpcode::G_GLOBAL_VALUE ||
983 I.getOpcode() == TargetOpcode::G_IMPLICIT_DEF);
984 if (spvSelect(ResVReg, ResType, I)) {
985 if (HasDefs) // Make all vregs 64 bits (for SPIR-V IDs).
986 for (unsigned i = 0; i < I.getNumDefs(); ++i)
987 MRI->setType(VReg: I.getOperand(i).getReg(), Ty: LLT::scalar(SizeInBits: 64));
988 GR.invalidateMachineInstr(MI: &I);
989 I.eraseFromParent();
990 return true;
991 }
992 return false;
993}
994
995static bool mayApplyGenericSelection(unsigned Opcode) {
996 switch (Opcode) {
997 case TargetOpcode::G_CONSTANT:
998 case TargetOpcode::G_FCONSTANT:
999 return false;
1000 }
1001 return isTypeFoldingSupported(Opcode);
1002}
1003
1004bool SPIRVInstructionSelector::BuildCOPY(Register DestReg, Register SrcReg,
1005 MachineInstr &I) const {
1006 const TargetRegisterClass *DstRC = MRI->getRegClassOrNull(Reg: DestReg);
1007 const TargetRegisterClass *SrcRC = MRI->getRegClassOrNull(Reg: SrcReg);
1008 if (DstRC != SrcRC && SrcRC)
1009 MRI->setRegClass(Reg: DestReg, RC: SrcRC);
1010 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: TargetOpcode::COPY))
1011 .addDef(RegNo: DestReg)
1012 .addUse(RegNo: SrcReg)
1013 .constrainAllUses(TII, TRI, RBI);
1014 return true;
1015}
1016
1017bool SPIRVInstructionSelector::spvSelect(Register ResVReg,
1018 SPIRVTypeInst ResType,
1019 MachineInstr &I) const {
1020 const unsigned Opcode = I.getOpcode();
1021 if (mayApplyGenericSelection(Opcode))
1022 return selectImpl(I, CoverageInfo&: *CoverageInfo);
1023 switch (Opcode) {
1024 case TargetOpcode::G_CONSTANT:
1025 case TargetOpcode::G_FCONSTANT:
1026 return selectConst(ResVReg, ResType, I);
1027 case TargetOpcode::G_GLOBAL_VALUE:
1028 return selectGlobalValue(ResVReg, I);
1029 case TargetOpcode::G_IMPLICIT_DEF:
1030 return selectOpUndef(ResVReg, ResType, I);
1031 case TargetOpcode::G_FREEZE:
1032 return selectFreeze(ResVReg, ResType, I);
1033
1034 case TargetOpcode::G_INTRINSIC:
1035 case TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS:
1036 case TargetOpcode::G_INTRINSIC_CONVERGENT:
1037 case TargetOpcode::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS:
1038 return selectIntrinsic(ResVReg, ResType, I);
1039 case TargetOpcode::G_BITREVERSE:
1040 return selectBitreverse(ResVReg, ResType, I);
1041
1042 case TargetOpcode::G_BUILD_VECTOR:
1043 return selectBuildVector(ResVReg, ResType, I);
1044 case TargetOpcode::G_SPLAT_VECTOR:
1045 return selectSplatVector(ResVReg, ResType, I);
1046 case TargetOpcode::G_CONCAT_VECTORS:
1047 return selectConcatVectors(ResVReg, ResType, I);
1048
1049 case TargetOpcode::G_SHUFFLE_VECTOR: {
1050 MachineBasicBlock &BB = *I.getParent();
1051 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
1052 .addDef(RegNo: ResVReg)
1053 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1054 .addUse(RegNo: I.getOperand(i: 1).getReg())
1055 .addUse(RegNo: I.getOperand(i: 2).getReg());
1056 for (auto V : I.getOperand(i: 3).getShuffleMask())
1057 MIB.addImm(Val: V);
1058 MIB.constrainAllUses(TII, TRI, RBI);
1059 return true;
1060 }
1061 case TargetOpcode::G_MEMMOVE:
1062 case TargetOpcode::G_MEMCPY:
1063 case TargetOpcode::G_MEMCPY_INLINE:
1064 case TargetOpcode::G_MEMSET:
1065 case TargetOpcode::G_MEMSET_INLINE:
1066 return selectMemOperation(ResVReg, I);
1067
1068 case TargetOpcode::G_ICMP:
1069 return selectICmp(ResVReg, ResType, I);
1070 case TargetOpcode::G_FCMP:
1071 return selectFCmp(ResVReg, ResType, I);
1072
1073 case TargetOpcode::G_FRAME_INDEX:
1074 return selectFrameIndex(ResVReg, ResType, I);
1075
1076 case TargetOpcode::G_LOAD:
1077 return selectLoad(ResVReg, ResType, I);
1078 case TargetOpcode::G_STORE:
1079 return selectStore(I);
1080
1081 case TargetOpcode::G_BR:
1082 return selectBranch(I);
1083 case TargetOpcode::G_BRCOND:
1084 return selectBranchCond(I);
1085
1086 case TargetOpcode::G_PHI:
1087 return selectPhi(ResVReg, I);
1088
1089 case TargetOpcode::G_FPTOSI:
1090 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertFToS);
1091 case TargetOpcode::G_FPTOUI:
1092 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertFToU);
1093
1094 case TargetOpcode::G_FPTOSI_SAT:
1095 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertFToS);
1096 case TargetOpcode::G_FPTOUI_SAT:
1097 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertFToU);
1098
1099 case TargetOpcode::G_SITOFP:
1100 return selectIToF(ResVReg, ResType, I, IsSigned: true, Opcode: SPIRV::OpConvertSToF);
1101 case TargetOpcode::G_UITOFP:
1102 return selectIToF(ResVReg, ResType, I, IsSigned: false, Opcode: SPIRV::OpConvertUToF);
1103
1104 case TargetOpcode::G_CTPOP:
1105 return selectPopCount(ResVReg, ResType, I, Opcode: SPIRV::OpBitCount);
1106 case TargetOpcode::G_SMIN:
1107 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_min, GLInst: GL::SMin);
1108 case TargetOpcode::G_UMIN:
1109 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_min, GLInst: GL::UMin);
1110
1111 case TargetOpcode::G_SMAX:
1112 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_max, GLInst: GL::SMax);
1113 case TargetOpcode::G_UMAX:
1114 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_max, GLInst: GL::UMax);
1115
1116 case TargetOpcode::G_SCMP:
1117 return selectSUCmp(ResVReg, ResType, I, IsSigned: true);
1118 case TargetOpcode::G_UCMP:
1119 return selectSUCmp(ResVReg, ResType, I, IsSigned: false);
1120 case TargetOpcode::G_LROUND:
1121 case TargetOpcode::G_LLROUND: {
1122 Register regForLround =
1123 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ResVReg), Name: "lround");
1124 MRI->setRegClass(Reg: regForLround, RC: &SPIRV::iIDRegClass);
1125 GR.assignSPIRVTypeToVReg(Type: GR.getSPIRVTypeForVReg(VReg: I.getOperand(i: 1).getReg()),
1126 VReg: regForLround, MF: *(I.getParent()->getParent()));
1127 selectExtInst(ResVReg: regForLround, ResType: GR.getSPIRVTypeForVReg(VReg: regForLround), I,
1128 CLInst: CL::round, GLInst: GL::Round, /* setMIFlags */ false);
1129 MachineBasicBlock &BB = *I.getParent();
1130 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpConvertFToS))
1131 .addDef(RegNo: ResVReg)
1132 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1133 .addUse(RegNo: regForLround);
1134 MIB.constrainAllUses(TII, TRI, RBI);
1135 return true;
1136 }
1137 case TargetOpcode::G_STRICT_FMA:
1138 case TargetOpcode::G_FMA: {
1139 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_fma)) {
1140 MachineBasicBlock &BB = *I.getParent();
1141 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpFmaKHR))
1142 .addDef(RegNo: ResVReg)
1143 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1144 .addUse(RegNo: I.getOperand(i: 1).getReg())
1145 .addUse(RegNo: I.getOperand(i: 2).getReg())
1146 .addUse(RegNo: I.getOperand(i: 3).getReg())
1147 .setMIFlags(I.getFlags());
1148 MIB.constrainAllUses(TII, TRI, RBI);
1149 return true;
1150 }
1151 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fma, GLInst: GL::Fma);
1152 }
1153
1154 case TargetOpcode::G_FLDEXP:
1155 case TargetOpcode::G_STRICT_FLDEXP:
1156 return selectLdexp(ResVReg, ResType, I);
1157
1158 case TargetOpcode::G_FPOW:
1159 return selectExtInst(ResVReg, ResType, I, CLInst: CL::pow, GLInst: GL::Pow);
1160 case TargetOpcode::G_FPOWI:
1161 return selectFpowi(ResVReg, ResType, I);
1162
1163 case TargetOpcode::G_FEXP:
1164 return selectExtInst(ResVReg, ResType, I, CLInst: CL::exp, GLInst: GL::Exp);
1165 case TargetOpcode::G_FEXP2:
1166 return selectExtInst(ResVReg, ResType, I, CLInst: CL::exp2, GLInst: GL::Exp2);
1167 case TargetOpcode::G_FEXP10:
1168 return selectExp10(ResVReg, ResType, I);
1169
1170 case TargetOpcode::G_FMODF:
1171 return selectModf(ResVReg, ResType, I);
1172 case TargetOpcode::G_FSINCOS:
1173 return selectSincos(ResVReg, ResType, I);
1174
1175 case TargetOpcode::G_FLOG:
1176 return selectExtInst(ResVReg, ResType, I, CLInst: CL::log, GLInst: GL::Log);
1177 case TargetOpcode::G_FLOG2:
1178 return selectExtInst(ResVReg, ResType, I, CLInst: CL::log2, GLInst: GL::Log2);
1179 case TargetOpcode::G_FLOG10:
1180 return selectLog10(ResVReg, ResType, I);
1181
1182 case TargetOpcode::G_FABS:
1183 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fabs, GLInst: GL::FAbs);
1184 case TargetOpcode::G_ABS:
1185 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_abs, GLInst: GL::SAbs);
1186
1187 case TargetOpcode::G_FMINNUM:
1188 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fmin, GLInst: GL::NMin);
1189 case TargetOpcode::G_FMAXNUM:
1190 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fmax, GLInst: GL::NMax);
1191
1192 case TargetOpcode::G_FCOPYSIGN:
1193 return selectCopySign(ResVReg, ResType, I);
1194
1195 case TargetOpcode::G_FCEIL:
1196 return selectExtInst(ResVReg, ResType, I, CLInst: CL::ceil, GLInst: GL::Ceil);
1197 case TargetOpcode::G_FFLOOR:
1198 return selectExtInst(ResVReg, ResType, I, CLInst: CL::floor, GLInst: GL::Floor);
1199
1200 case TargetOpcode::G_FCOS:
1201 return selectExtInst(ResVReg, ResType, I, CLInst: CL::cos, GLInst: GL::Cos);
1202 case TargetOpcode::G_FSIN:
1203 return selectExtInst(ResVReg, ResType, I, CLInst: CL::sin, GLInst: GL::Sin);
1204 case TargetOpcode::G_FTAN:
1205 return selectExtInst(ResVReg, ResType, I, CLInst: CL::tan, GLInst: GL::Tan);
1206 case TargetOpcode::G_FACOS:
1207 return selectExtInst(ResVReg, ResType, I, CLInst: CL::acos, GLInst: GL::Acos);
1208 case TargetOpcode::G_FASIN:
1209 return selectExtInst(ResVReg, ResType, I, CLInst: CL::asin, GLInst: GL::Asin);
1210 case TargetOpcode::G_FATAN:
1211 return selectExtInst(ResVReg, ResType, I, CLInst: CL::atan, GLInst: GL::Atan);
1212 case TargetOpcode::G_FATAN2:
1213 return selectExtInst(ResVReg, ResType, I, CLInst: CL::atan2, GLInst: GL::Atan2);
1214 case TargetOpcode::G_FCOSH:
1215 return selectExtInst(ResVReg, ResType, I, CLInst: CL::cosh, GLInst: GL::Cosh);
1216 case TargetOpcode::G_FSINH:
1217 return selectExtInst(ResVReg, ResType, I, CLInst: CL::sinh, GLInst: GL::Sinh);
1218 case TargetOpcode::G_FTANH:
1219 return selectExtInst(ResVReg, ResType, I, CLInst: CL::tanh, GLInst: GL::Tanh);
1220
1221 case TargetOpcode::G_STRICT_FSQRT:
1222 case TargetOpcode::G_FSQRT:
1223 return selectExtInst(ResVReg, ResType, I, CLInst: CL::sqrt, GLInst: GL::Sqrt);
1224
1225 case TargetOpcode::G_CTTZ:
1226 case TargetOpcode::G_CTTZ_ZERO_POISON:
1227 return selectExtInst(ResVReg, ResType, I, CLInst: CL::ctz);
1228 case TargetOpcode::G_CTLZ:
1229 case TargetOpcode::G_CTLZ_ZERO_POISON:
1230 return selectExtInst(ResVReg, ResType, I, CLInst: CL::clz);
1231
1232 case TargetOpcode::G_INTRINSIC_ROUND:
1233 return selectExtInst(ResVReg, ResType, I, CLInst: CL::round, GLInst: GL::Round);
1234 case TargetOpcode::G_INTRINSIC_ROUNDEVEN:
1235 return selectExtInst(ResVReg, ResType, I, CLInst: CL::rint, GLInst: GL::RoundEven);
1236 case TargetOpcode::G_INTRINSIC_TRUNC:
1237 return selectExtInst(ResVReg, ResType, I, CLInst: CL::trunc, GLInst: GL::Trunc);
1238 case TargetOpcode::G_FRINT:
1239 case TargetOpcode::G_FNEARBYINT:
1240 return selectExtInst(ResVReg, ResType, I, CLInst: CL::rint, GLInst: GL::RoundEven);
1241
1242 case TargetOpcode::G_SMULH:
1243 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_mul_hi);
1244 case TargetOpcode::G_UMULH:
1245 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_mul_hi);
1246
1247 case TargetOpcode::G_SADDSAT:
1248 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_add_sat);
1249 case TargetOpcode::G_UADDSAT:
1250 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_add_sat);
1251 case TargetOpcode::G_SSUBSAT:
1252 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_sub_sat);
1253 case TargetOpcode::G_USUBSAT:
1254 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_sub_sat);
1255
1256 case TargetOpcode::G_FFREXP:
1257 return selectFrexp(ResVReg, ResType, I);
1258
1259 case TargetOpcode::G_UADDO:
1260 return selectOverflowArith(ResVReg, ResType, I,
1261 Opcode: isVectorType(SPVTy: ResType) ? SPIRV::OpIAddCarryV
1262 : SPIRV::OpIAddCarryS);
1263 case TargetOpcode::G_USUBO:
1264 return selectOverflowArith(ResVReg, ResType, I,
1265 Opcode: isVectorType(SPVTy: ResType) ? SPIRV::OpISubBorrowV
1266 : SPIRV::OpISubBorrowS);
1267 case TargetOpcode::G_UMULO:
1268 return selectOverflowArith(ResVReg, ResType, I, Opcode: SPIRV::OpUMulExtended);
1269 case TargetOpcode::G_SMULO:
1270 return selectOverflowArith(ResVReg, ResType, I, Opcode: SPIRV::OpSMulExtended);
1271
1272 case TargetOpcode::G_SEXT:
1273 return selectExt(ResVReg, ResType, I, IsSigned: true);
1274 case TargetOpcode::G_ANYEXT:
1275 case TargetOpcode::G_ZEXT:
1276 return selectExt(ResVReg, ResType, I, IsSigned: false);
1277 case TargetOpcode::G_TRUNC:
1278 return selectTrunc(ResVReg, ResType, I);
1279 case TargetOpcode::G_FPTRUNC:
1280 case TargetOpcode::G_FPEXT:
1281 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpFConvert);
1282
1283 case TargetOpcode::G_PTRTOINT:
1284 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertPtrToU);
1285 case TargetOpcode::G_INTTOPTR:
1286 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpConvertUToPtr);
1287 case TargetOpcode::G_BITCAST:
1288 return selectBitcast(ResVReg, ResType, I);
1289 case TargetOpcode::G_ADDRSPACE_CAST:
1290 return selectAddrSpaceCast(ResVReg, ResType, I);
1291 case TargetOpcode::G_PTRMASK:
1292 return selectPtrMask(ResVReg, ResType, I);
1293 case TargetOpcode::G_PTR_ADD: {
1294 // Currently, we get G_PTR_ADD only applied to global variables, possibly
1295 // through an address space cast.
1296 assert(I.getOperand(1).isReg() && I.getOperand(2).isReg());
1297 Register GV = I.getOperand(i: 1).getReg();
1298 MachineRegisterInfo::def_instr_iterator II = MRI->def_instr_begin(RegNo: GV);
1299 const bool IsAddrSpaceCast =
1300 (*II).getOpcode() == TargetOpcode::G_ADDRSPACE_CAST;
1301 assert(((*II).getOpcode() == TargetOpcode::G_GLOBAL_VALUE ||
1302 (*II).getOpcode() == TargetOpcode::COPY || IsAddrSpaceCast ||
1303 (*II).getOpcode() == SPIRV::OpVariable ||
1304 (*II).getOpcode() == SPIRV::OpUntypedVariableKHR) &&
1305 getImm(I.getOperand(2), MRI));
1306 // It may be the initialization of a global variable.
1307 bool IsGVInit = false;
1308 for (MachineRegisterInfo::use_instr_iterator
1309 UseIt = MRI->use_instr_begin(RegNo: I.getOperand(i: 0).getReg()),
1310 UseEnd = MRI->use_instr_end();
1311 UseIt != UseEnd; UseIt = std::next(x: UseIt)) {
1312 if ((*UseIt).getOpcode() == TargetOpcode::G_GLOBAL_VALUE ||
1313 (*UseIt).getOpcode() == SPIRV::OpSpecConstantOp ||
1314 (*UseIt).getOpcode() == SPIRV::OpVariable ||
1315 (*UseIt).getOpcode() == SPIRV::OpUntypedVariableKHR) {
1316 IsGVInit = true;
1317 break;
1318 }
1319 }
1320 // An address space cast of null can be typed as an integer, but the base of
1321 // an access chain must be a pointer. Other integer-typed casts cannot be
1322 // represented by replacing their base with a pointer constant.
1323 if (SPIRVTypeInst BaseType = GR.getSPIRVTypeForVReg(VReg: GV);
1324 IsAddrSpaceCast && (!BaseType || !BaseType.isPointer())) {
1325 if (!getImm(MO: (*II).getOperand(i: 1), MRI) ||
1326 foldImm(MO: (*II).getOperand(i: 1), MRI) != 0)
1327 return diagnoseUnsupported(
1328 I, Msg: "address space cast of a non-null integer used as a G_PTR_ADD "
1329 "base");
1330 SPIRVTypeInst NullPtrTy =
1331 getUcharPtrType(I, SC: GR.getPointerStorageClass(Type: ResType));
1332 MachineBasicBlock &DepMBB = I.getMF()->front();
1333 MachineIRBuilder MIRBuilder(DepMBB, DepMBB.getFirstNonPHI());
1334 GV = GR.getOrCreateConstNullPtr(MIRBuilder, SpvType: NullPtrTy);
1335 }
1336 MachineBasicBlock &BB = *I.getParent();
1337 // An untyped result needs OpUntypedInBoundsPtrAccessChainKHR, which spells
1338 // out the Base Type. The offset of G_PTR_ADD is a byte count, so the Base
1339 // Type is i8 and the offset is the Element index as is. The opcode is
1340 // picked by the result type alone because an untyped access chain accepts
1341 // a typed base while a typed access chain rejects an untyped result.
1342 SPIRVTypeInst GVType = GR.getSPIRVTypeForVReg(VReg: GV);
1343 const bool UseUntypedPointers =
1344 ResType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
1345 if (UseUntypedPointers) {
1346 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
1347 .addDef(RegNo: ResVReg)
1348 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1349 .addImm(Val: static_cast<uint32_t>(
1350 SPIRV::Opcode::UntypedInBoundsPtrAccessChainKHR))
1351 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: GR.getOrCreateSPIRVIntegerType(BitWidth: 8, I, TII)))
1352 .addUse(RegNo: GV)
1353 .addUse(RegNo: I.getOperand(i: 2).getReg())
1354 .constrainAllUses(TII, TRI, RBI);
1355 return true;
1356 }
1357 if (!IsGVInit) {
1358 SPIRVTypeInst GVPointeeType = GR.getPointeeType(PtrType: GVType);
1359 SPIRVTypeInst ResPointeeType = GR.getPointeeType(PtrType: ResType);
1360 if (GVPointeeType && ResPointeeType && GVPointeeType != ResPointeeType) {
1361 // Build a new virtual register that is associated with the required
1362 // data type.
1363 Register NewVReg = MRI->createGenericVirtualRegister(Ty: MRI->getType(Reg: GV));
1364 MRI->setRegClass(Reg: NewVReg, RC: MRI->getRegClass(Reg: GV));
1365 // Having a correctly typed base we are ready to build the actually
1366 // required GEP. It may not be a constant though, because all Operands
1367 // of OpSpecConstantOp is to originate from other const instructions,
1368 // and only the AccessChain named opcodes accept a global OpVariable
1369 // instruction. We can't use an AccessChain opcode because of the type
1370 // mismatch between result and base types.
1371 if (!GR.isBitcastCompatible(Type1: ResType, Type2: GVType))
1372 return diagnoseUnsupported(
1373 I, Msg: "incompatible result and operand types in a bitcast");
1374 Register ResTypeReg = GR.getSPIRVTypeID(SpirvType: ResType);
1375 MachineInstrBuilder MIB =
1376 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBitcast))
1377 .addDef(RegNo: NewVReg)
1378 .addUse(RegNo: ResTypeReg)
1379 .addUse(RegNo: GV);
1380 MIB.constrainAllUses(TII, TRI, RBI);
1381 BuildMI(BB, I, MIMD: I.getDebugLoc(),
1382 MCID: TII.get(Opcode: STI.isLogicalSPIRV() ? SPIRV::OpInBoundsAccessChain
1383 : SPIRV::OpInBoundsPtrAccessChain))
1384 .addDef(RegNo: ResVReg)
1385 .addUse(RegNo: ResTypeReg)
1386 .addUse(RegNo: NewVReg)
1387 .addUse(RegNo: I.getOperand(i: 2).getReg())
1388 .constrainAllUses(TII, TRI, RBI);
1389 } else {
1390 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
1391 .addDef(RegNo: ResVReg)
1392 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1393 .addImm(
1394 Val: static_cast<uint32_t>(SPIRV::Opcode::InBoundsPtrAccessChain))
1395 .addUse(RegNo: GV)
1396 .addUse(RegNo: I.getOperand(i: 2).getReg())
1397 .constrainAllUses(TII, TRI, RBI);
1398 }
1399 return true;
1400 }
1401 // The offset of G_PTR_ADD is a byte count, so bitcast a typed base to i8*
1402 // in its own storage class and use that offset as the Element operand.
1403 // selectAddrSpaceCast() later defines an address-space cast as that i8*
1404 // pointer, so no bitcast is emitted for a cast. An i8* base is unchanged.
1405 Register ChainBase = IsAddrSpaceCast ? GV : bitcastConstPtrToI8(I, Src: GV);
1406
1407 // It's possible to translate G_PTR_ADD to OpSpecConstantOp: either to
1408 // initialize a global variable with a constant expression (e.g., the test
1409 // case opencl/basic/progvar_prog_scope_init.ll), or for another use case
1410 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
1411 .addDef(RegNo: ResVReg)
1412 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1413 .addImm(Val: static_cast<uint32_t>(SPIRV::Opcode::InBoundsPtrAccessChain))
1414 .addUse(RegNo: ChainBase)
1415 .addUse(RegNo: I.getOperand(i: 2).getReg())
1416 .constrainAllUses(TII, TRI, RBI);
1417 return true;
1418 }
1419
1420 case TargetOpcode::G_ATOMICRMW_OR:
1421 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicOr);
1422 case TargetOpcode::G_ATOMICRMW_ADD:
1423 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicIAdd);
1424 case TargetOpcode::G_ATOMICRMW_AND:
1425 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicAnd);
1426 case TargetOpcode::G_ATOMICRMW_MAX:
1427 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicSMax);
1428 case TargetOpcode::G_ATOMICRMW_MIN:
1429 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicSMin);
1430 case TargetOpcode::G_ATOMICRMW_SUB:
1431 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicISub);
1432 case TargetOpcode::G_ATOMICRMW_XOR:
1433 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicXor);
1434 case TargetOpcode::G_ATOMICRMW_UMAX:
1435 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicUMax);
1436 case TargetOpcode::G_ATOMICRMW_UMIN:
1437 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicUMin);
1438 case TargetOpcode::G_ATOMICRMW_XCHG:
1439 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicExchange);
1440
1441 case TargetOpcode::G_ATOMICRMW_FADD:
1442 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicFAddEXT);
1443 case TargetOpcode::G_ATOMICRMW_FSUB:
1444 // Translate G_ATOMICRMW_FSUB to OpAtomicFAddEXT with negative value operand
1445 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicFAddEXT,
1446 NegateOpcode: isVectorType(SPVTy: ResType) ? SPIRV::OpFNegateV
1447 : SPIRV::OpFNegate);
1448 case TargetOpcode::G_ATOMICRMW_FMIN:
1449 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicFMinEXT);
1450 case TargetOpcode::G_ATOMICRMW_FMAX:
1451 return selectAtomicRMW(ResVReg, ResType, I, NewOpcode: SPIRV::OpAtomicFMaxEXT);
1452
1453 case TargetOpcode::G_FENCE:
1454 return selectFence(I);
1455
1456 case TargetOpcode::G_STACKSAVE:
1457 return selectStackSave(ResVReg, ResType, I);
1458 case TargetOpcode::G_STACKRESTORE:
1459 return selectStackRestore(I);
1460
1461 case TargetOpcode::G_UNMERGE_VALUES:
1462 return selectUnmergeValues(I);
1463
1464 case TargetOpcode::G_TRAP:
1465 case TargetOpcode::G_UBSANTRAP:
1466 return selectTrap(I);
1467
1468 // Discard gen opcodes for intrinsics which we do not expect to actually
1469 // represent code after lowering or intrinsics which are not implemented but
1470 // should not crash when found in a customer's LLVM IR input.
1471 case TargetOpcode::DBG_LABEL:
1472 return true;
1473 case TargetOpcode::G_DEBUGTRAP:
1474 return selectDebugTrap(ResVReg, ResType, I);
1475 case TargetOpcode::G_PREFETCH:
1476 return selectPrefetch(I);
1477
1478 default:
1479 return false;
1480 }
1481}
1482
1483bool SPIRVInstructionSelector::selectDebugTrap(Register ResVReg,
1484 SPIRVTypeInst ResType,
1485 MachineInstr &I) const {
1486 if (!STI.canUseExtInstSet(E: SPIRV::InstructionSet::NonSemantic_DebugBreak)) {
1487 MachineBasicBlock &BB = *I.getParent();
1488 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpNop))
1489 .constrainAllUses(TII, TRI, RBI);
1490 return true;
1491 }
1492 MachineIRBuilder MIRBuilder(I);
1493 SPIRVTypeInst VoidTy = GR.getOpTypeVoid(MIRBuilder);
1494 Register ExtReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: VoidTy));
1495 return selectExtInst(ResVReg: ExtReg, ResType: VoidTy, I,
1496 ExtInsts: {{SPIRV::InstructionSet::NonSemantic_DebugBreak,
1497 SPIRV::NonSemanticDebugBreakExtInst::DebugBreak}},
1498 /*setMIFlags=*/false, /*useMISrc=*/false);
1499}
1500
1501bool SPIRVInstructionSelector::selectPrefetch(MachineInstr &I) const {
1502 // llvm.prefetch is missing info about how many bytes to prefetch that
1503 // OpUntypedPrefetchKHR instruction requires, so just drop the instruction
1504 // in case untyped pointers are enabled since OCL prefetch cannot take
1505 // untyped pointers.
1506 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_untyped_pointers))
1507 return true;
1508
1509 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std)) {
1510 MachineIRBuilder MIRBuilder(I);
1511 const unsigned PointerSize = GR.getPointerSize();
1512 const SPIRVTypeInst PointerSizeType =
1513 GR.getOrCreateSPIRVIntegerType(BitWidth: PointerSize, MIRBuilder);
1514 bool ZeroAsNull = !STI.isShader();
1515
1516 // Assume that a single element needs prefetch.
1517 Register ConstIntOne =
1518 GR.getOrCreateConstInt(Val: 1, I, SpvType: PointerSizeType, TII, ZeroAsNull);
1519
1520 Register AddrVal = I.getOperand(i: 0).getReg();
1521 Register ExtReg = MRI->createVirtualRegister(
1522 RegClass: GR.getRegClass(SpvType: GR.getOpTypeVoid(MIRBuilder)));
1523 return selectExtInst(ResVReg: ExtReg, ResType: GR.getOpTypeVoid(MIRBuilder), I, CLInst: CL::prefetch,
1524 /*setMIFlags=*/false, /*useMSSrc=*/useMISrc: false,
1525 SrcRegs: {AddrVal, ConstIntOne});
1526 }
1527 return true;
1528}
1529
1530bool SPIRVInstructionSelector::selectExtInst(Register ResVReg,
1531 SPIRVTypeInst ResType,
1532 MachineInstr &I,
1533 GL::GLSLExtInst GLInst,
1534 bool setMIFlags, bool useMISrc,
1535 ArrayRef<Register> SrcRegs) const {
1536 if (!STI.canUseExtInstSet(
1537 E: SPIRV::InstructionSet::InstructionSet::GLSL_std_450))
1538 return diagnoseUnsupported(
1539 I,
1540 Msg: "this instruction is only supported with the GLSL extended instruction "
1541 "set.");
1542 return selectExtInst(ResVReg, ResType, I,
1543 ExtInsts: {{SPIRV::InstructionSet::GLSL_std_450, GLInst}},
1544 setMIFlags, useMISrc, SrcRegs);
1545}
1546
1547bool SPIRVInstructionSelector::selectExtInst(Register ResVReg,
1548 SPIRVTypeInst ResType,
1549 MachineInstr &I,
1550 CL::OpenCLExtInst CLInst,
1551 bool setMIFlags, bool useMISrc,
1552 ArrayRef<Register> SrcRegs) const {
1553 return selectExtInst(ResVReg, ResType, I,
1554 ExtInsts: {{SPIRV::InstructionSet::OpenCL_std, CLInst}},
1555 setMIFlags, useMISrc, SrcRegs);
1556}
1557
1558bool SPIRVInstructionSelector::selectExtInst(
1559 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
1560 CL::OpenCLExtInst CLInst, GL::GLSLExtInst GLInst, bool setMIFlags,
1561 bool useMISrc, ArrayRef<Register> SrcRegs) const {
1562 ExtInstList ExtInsts = {{SPIRV::InstructionSet::OpenCL_std, CLInst},
1563 {SPIRV::InstructionSet::GLSL_std_450, GLInst}};
1564 return selectExtInst(ResVReg, ResType, I, ExtInsts, setMIFlags, useMISrc,
1565 SrcRegs);
1566}
1567
1568bool SPIRVInstructionSelector::selectExtInst(Register ResVReg,
1569 SPIRVTypeInst ResType,
1570 MachineInstr &I,
1571 const ExtInstList &Insts,
1572 bool setMIFlags, bool useMISrc,
1573 ArrayRef<Register> SrcRegs) const {
1574
1575 for (const auto &[InstructionSet, Opcode] : Insts) {
1576 if (!STI.canUseExtInstSet(E: InstructionSet))
1577 continue;
1578 MachineBasicBlock &BB = *I.getParent();
1579 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
1580 .addDef(RegNo: ResVReg)
1581 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1582 .addImm(Val: static_cast<uint32_t>(InstructionSet))
1583 .addImm(Val: Opcode);
1584 if (setMIFlags)
1585 MIB.setMIFlags(I.getFlags());
1586 if (useMISrc) {
1587 const unsigned NumOps = I.getNumOperands();
1588 unsigned Index = 1;
1589 if (Index < NumOps &&
1590 I.getOperand(i: Index).getType() ==
1591 MachineOperand::MachineOperandType::MO_IntrinsicID)
1592 Index = 2;
1593 for (; Index < NumOps; ++Index)
1594 MIB.add(MO: I.getOperand(i: Index));
1595 } else {
1596 for (Register SReg : SrcRegs) {
1597 MIB.addUse(RegNo: SReg);
1598 }
1599 }
1600 MIB.constrainAllUses(TII, TRI, RBI);
1601 return true;
1602 }
1603 return false;
1604}
1605
1606bool SPIRVInstructionSelector::selectCopySign(Register ResVReg,
1607 SPIRVTypeInst ResType,
1608 MachineInstr &I) const {
1609 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std))
1610 return selectExtInst(ResVReg, ResType, I, CLInst: CL::copysign);
1611
1612 // There is no copysign instruction in the GLSL Extended Instruction set, so
1613 // it is implemented with bit manipulation:
1614 // bitcast((bitcast(magnitude) & ~signBit) | (bitcast(sign) & signBit))
1615 Register MagnitudeReg = I.getOperand(i: 1).getReg();
1616 Register SignReg = I.getOperand(i: 2).getReg();
1617
1618 const unsigned BitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
1619 const unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: ResType);
1620 SPIRVTypeInst IntType = GR.getOrCreateSPIRVIntegerType(BitWidth, I, TII);
1621 const APInt SignMaskVal = APInt::getSignMask(BitWidth);
1622
1623 Register SignMask, NotSignMask;
1624 unsigned AndOpcode, OrOpcode;
1625 if (ComponentCount > 1) {
1626 IntType = GR.getOrCreateSPIRVVectorType(BaseType: IntType, NumElements: ComponentCount, I, TII);
1627 SignMask = GR.getOrCreateConstVector(Val: SignMaskVal, I, SpvType: IntType, TII);
1628 NotSignMask = GR.getOrCreateConstVector(Val: ~SignMaskVal, I, SpvType: IntType, TII);
1629 AndOpcode = SPIRV::OpBitwiseAndV;
1630 OrOpcode = SPIRV::OpBitwiseOrV;
1631 } else {
1632 SignMask = GR.getOrCreateConstInt(Val: SignMaskVal, I, SpvType: IntType, TII);
1633 NotSignMask = GR.getOrCreateConstInt(Val: ~SignMaskVal, I, SpvType: IntType, TII);
1634 AndOpcode = SPIRV::OpBitwiseAndS;
1635 OrOpcode = SPIRV::OpBitwiseOrS;
1636 }
1637
1638 auto EmitBitOp = [&](Register &ResReg, ArrayRef<Register> SrcRegs,
1639 unsigned Opcode) {
1640 ResReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: IntType));
1641 return selectOpWithSrcs(ResVReg: ResReg, ResType: IntType, I, SrcRegs, Opcode);
1642 };
1643
1644 Register MagnitudeInt, SignInt, MagnitudeBits, SignBits, CombinedInt;
1645 if (!EmitBitOp(MagnitudeInt, {MagnitudeReg}, SPIRV::OpBitcast) ||
1646 !EmitBitOp(SignInt, {SignReg}, SPIRV::OpBitcast) ||
1647 !EmitBitOp(MagnitudeBits, {MagnitudeInt, NotSignMask}, AndOpcode) ||
1648 !EmitBitOp(SignBits, {SignInt, SignMask}, AndOpcode) ||
1649 !EmitBitOp(CombinedInt, {MagnitudeBits, SignBits}, OrOpcode))
1650 return false;
1651
1652 return selectOpWithSrcs(ResVReg, ResType, I, SrcRegs: {CombinedInt}, Opcode: SPIRV::OpBitcast);
1653}
1654
1655bool SPIRVInstructionSelector::selectFrexp(Register ResVReg,
1656 SPIRVTypeInst ResType,
1657 MachineInstr &I) const {
1658 ExtInstList ExtInsts = {{SPIRV::InstructionSet::OpenCL_std, CL::frexp},
1659 {SPIRV::InstructionSet::GLSL_std_450, GL::Frexp}};
1660 for (const auto &Ex : ExtInsts) {
1661 SPIRV::InstructionSet::InstructionSet Set = Ex.first;
1662 uint32_t Opcode = Ex.second;
1663 if (!STI.canUseExtInstSet(E: Set))
1664 continue;
1665
1666 MachineIRBuilder MIRBuilder(I);
1667 SPIRVTypeInst PointeeTy = GR.getSPIRVTypeForVReg(VReg: I.getOperand(i: 1).getReg());
1668 const SPIRVTypeInst PointerType = GR.getOrCreateSPIRVPointerType(
1669 BaseType: PointeeTy, MIRBuilder, SC: SPIRV::StorageClass::Function);
1670 Register PointerVReg =
1671 createVirtualRegister(SpvType: PointerType, GR: &GR, MRI, MF: MRI->getMF());
1672
1673 auto It = getOpVariableMBBIt(MF&: *I.getMF());
1674 // An untyped pointer result type is only legal on OpUntypedVariableKHR,
1675 // but not on OpVariable.
1676 const bool IsUntyped =
1677 PointerType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
1678 auto VarMIB =
1679 BuildMI(BB&: *It->getParent(), I: It, MIMD: It->getDebugLoc(),
1680 MCID: TII.get(Opcode: IsUntyped ? SPIRV::OpUntypedVariableKHR
1681 : SPIRV::OpVariable))
1682 .addDef(RegNo: PointerVReg)
1683 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PointerType))
1684 .addImm(Val: static_cast<uint32_t>(SPIRV::StorageClass::Function));
1685 if (IsUntyped)
1686 VarMIB.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PointeeTy)); // Data Type
1687 VarMIB.constrainAllUses(TII, TRI, RBI);
1688
1689 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
1690 .addDef(RegNo: ResVReg)
1691 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1692 .addImm(Val: static_cast<uint32_t>(Ex.first))
1693 .addImm(Val: Opcode)
1694 .add(MO: I.getOperand(i: 2))
1695 .addUse(RegNo: PointerVReg)
1696 .constrainAllUses(TII, TRI, RBI);
1697
1698 Register ExpResReg = I.getOperand(i: 1).getReg();
1699 if (!MRI->use_nodbg_empty(RegNo: ExpResReg))
1700 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoad))
1701 .addDef(RegNo: ExpResReg)
1702 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PointeeTy))
1703 .addUse(RegNo: PointerVReg)
1704 .constrainAllUses(TII, TRI, RBI);
1705 return true;
1706 }
1707 return false;
1708}
1709
1710bool SPIRVInstructionSelector::selectLdexp(Register ResVReg,
1711 SPIRVTypeInst ResType,
1712 MachineInstr &I) const {
1713 Register XReg = I.getOperand(i: 1).getReg();
1714 Register ExpReg = I.getOperand(i: 2).getReg();
1715 return selectExtInst(ResVReg, ResType, I, CLInst: CL::ldexp, GLInst: GL::Ldexp,
1716 /*setMIFlags=*/true, /*useMISrc=*/false, SrcRegs: {XReg, ExpReg});
1717}
1718
1719bool SPIRVInstructionSelector::selectSincos(Register ResVReg,
1720 SPIRVTypeInst ResType,
1721 MachineInstr &I) const {
1722 Register CosResVReg = I.getOperand(i: 1).getReg();
1723 unsigned SrcIdx = I.getNumExplicitDefs();
1724 Register ResTypeReg = GR.getSPIRVTypeID(SpirvType: ResType);
1725
1726 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std)) {
1727 // OpenCL.std sincos(x, cosval*) -> returns sin(x), writes cos(x) to ptr.
1728 MachineIRBuilder MIRBuilder(I);
1729 const SPIRVTypeInst PointerType = GR.getOrCreateSPIRVPointerType(
1730 BaseType: ResType, MIRBuilder, SC: SPIRV::StorageClass::Function);
1731 Register PointerVReg =
1732 createVirtualRegister(SpvType: PointerType, GR: &GR, MRI, MF: MRI->getMF());
1733
1734 auto It = getOpVariableMBBIt(MF&: *I.getMF());
1735 // An untyped pointer result type is only legal on OpUntypedVariableKHR,
1736 // but not on OpVariable.
1737 const bool IsUntyped =
1738 PointerType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
1739 auto VarMIB =
1740 BuildMI(BB&: *It->getParent(), I: It, MIMD: It->getDebugLoc(),
1741 MCID: TII.get(Opcode: IsUntyped ? SPIRV::OpUntypedVariableKHR
1742 : SPIRV::OpVariable))
1743 .addDef(RegNo: PointerVReg)
1744 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PointerType))
1745 .addImm(Val: static_cast<uint32_t>(SPIRV::StorageClass::Function));
1746 if (IsUntyped)
1747 VarMIB.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType)); // Data Type
1748 VarMIB.constrainAllUses(TII, TRI, RBI);
1749 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
1750 .addDef(RegNo: ResVReg)
1751 .addUse(RegNo: ResTypeReg)
1752 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::OpenCL_std))
1753 .addImm(Val: CL::sincos)
1754 .add(MO: I.getOperand(i: SrcIdx))
1755 .addUse(RegNo: PointerVReg)
1756 .constrainAllUses(TII, TRI, RBI);
1757 if (!MRI->use_nodbg_empty(RegNo: CosResVReg))
1758 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoad))
1759 .addDef(RegNo: CosResVReg)
1760 .addUse(RegNo: ResTypeReg)
1761 .addUse(RegNo: PointerVReg)
1762 .constrainAllUses(TII, TRI, RBI);
1763 return true;
1764 } else if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::GLSL_std_450)) {
1765 // GLSL.std.450 has no combined sincos; emit separate Sin and Cos.
1766 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
1767 .addDef(RegNo: ResVReg)
1768 .addUse(RegNo: ResTypeReg)
1769 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
1770 .addImm(Val: GL::Sin)
1771 .add(MO: I.getOperand(i: SrcIdx))
1772 .constrainAllUses(TII, TRI, RBI);
1773 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
1774 .addDef(RegNo: CosResVReg)
1775 .addUse(RegNo: ResTypeReg)
1776 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
1777 .addImm(Val: GL::Cos)
1778 .add(MO: I.getOperand(i: SrcIdx))
1779 .constrainAllUses(TII, TRI, RBI);
1780 return true;
1781 }
1782 return false;
1783}
1784
1785bool SPIRVInstructionSelector::selectOpWithSrcs(Register ResVReg,
1786 SPIRVTypeInst ResType,
1787 MachineInstr &I,
1788 ArrayRef<Register> Srcs,
1789 unsigned Opcode) const {
1790 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
1791 .addDef(RegNo: ResVReg)
1792 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
1793 for (Register SReg : Srcs) {
1794 MIB.addUse(RegNo: SReg);
1795 }
1796 MIB.constrainAllUses(TII, TRI, RBI);
1797 return true;
1798}
1799
1800bool SPIRVInstructionSelector::selectPopCount16(Register ResVReg,
1801 SPIRVTypeInst ResType,
1802 MachineInstr &I,
1803 unsigned ExtOpcode,
1804 unsigned Opcode) const {
1805 MachineIRBuilder MIRBuilder(I);
1806
1807 Register OpReg = I.getOperand(i: 1).getReg();
1808 SPIRVTypeInst SrcType = GR.getSPIRVTypeForVReg(VReg: OpReg);
1809 unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: SrcType);
1810 bool IsScalar = !isVectorType(SPVTy: SrcType);
1811 SPIRVTypeInst I32Type = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, MIRBuilder);
1812
1813 SPIRVTypeInst ExtType =
1814 IsScalar ? I32Type
1815 : GR.getOrCreateSPIRVVectorType(BaseType: I32Type, NumElements: ComponentCount,
1816 MIRBuilder, /*IsSigned=*/EmitIR: false);
1817
1818 Register ExtReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ExtType));
1819 // Always use OpUConvert to always use a 0 extend
1820 if (!selectOpWithSrcs(ResVReg: ExtReg, ResType: ExtType, I, Srcs: {OpReg}, Opcode: SPIRV::OpUConvert))
1821 return false;
1822
1823 Register PopCountReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ExtType));
1824 if (!selectPopCount32(ResVReg: PopCountReg, ResType: ExtType, I, SrcReg: ExtReg, Opcode))
1825 return false;
1826
1827 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {PopCountReg}, Opcode: ExtOpcode);
1828}
1829
1830bool SPIRVInstructionSelector::selectPopCount32(Register ResVReg,
1831 SPIRVTypeInst ResType,
1832 MachineInstr &I,
1833 Register SrcReg,
1834 unsigned Opcode) const {
1835 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {SrcReg}, Opcode);
1836}
1837
1838bool SPIRVInstructionSelector::selectPopCount64(Register ResVReg,
1839 SPIRVTypeInst ResType,
1840 MachineInstr &I,
1841 Register SrcReg,
1842 unsigned Opcode) const {
1843 MachineIRBuilder MIRBuilder(I);
1844
1845 SPIRVTypeInst SrcType = GR.getSPIRVTypeForVReg(VReg: SrcReg);
1846 unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: SrcType);
1847 bool IsScalar = !isVectorType(SPVTy: SrcType);
1848 SPIRVTypeInst I32Type = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, MIRBuilder);
1849
1850 // We need to work with a type matching the shape of the input but using 32
1851 // bit int instead of 64.
1852 SPIRVTypeInst WorkingType =
1853 IsScalar ? I32Type
1854 : GR.getOrCreateSPIRVVectorType(BaseType: I32Type, NumElements: ComponentCount,
1855 MIRBuilder, /*IsSigned=*/EmitIR: false);
1856
1857 // Truncate and count the low bits.
1858 Register Trunc = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WorkingType));
1859 if (!selectOpWithSrcs(ResVReg: Trunc, ResType: WorkingType, I, Srcs: {SrcReg}, Opcode: SPIRV::OpUConvert))
1860 return false;
1861
1862 Register LowCount = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WorkingType));
1863 if (!selectOpWithSrcs(ResVReg: LowCount, ResType: WorkingType, I, Srcs: {Trunc}, Opcode: SPIRV::OpBitCount))
1864 return false;
1865
1866 // Shift the high bits over and count them too.
1867 Register ShiftAmount = IsScalar
1868 ? GR.getOrCreateConstInt(Val: 32, I, SpvType: SrcType, TII)
1869 : GR.getOrCreateConstVector(Val: 32, I, SpvType: SrcType, TII);
1870 unsigned ShiftOp =
1871 IsScalar ? SPIRV::OpShiftRightLogicalS : SPIRV::OpShiftRightLogicalV;
1872 Register Shift = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: SrcType));
1873 if (!selectOpWithSrcs(ResVReg: Shift, ResType: SrcType, I, Srcs: {SrcReg, ShiftAmount}, Opcode: ShiftOp))
1874 return false;
1875
1876 Trunc = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WorkingType));
1877 if (!selectOpWithSrcs(ResVReg: Trunc, ResType: WorkingType, I, Srcs: {Shift}, Opcode: SPIRV::OpUConvert))
1878 return false;
1879
1880 Register HighCount = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WorkingType));
1881 if (!selectOpWithSrcs(ResVReg: HighCount, ResType: WorkingType, I, Srcs: {Trunc}, Opcode: SPIRV::OpBitCount))
1882 return false;
1883
1884 // Add them up and zext or sext back to 64 bit values.
1885 Register Sum = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WorkingType));
1886 if (!selectOpWithSrcs(ResVReg: Sum, ResType: WorkingType, I, Srcs: {HighCount, LowCount},
1887 Opcode: IsScalar ? SPIRV::OpIAddS : SPIRV::OpIAddV))
1888 return false;
1889
1890 bool IsSigned = GR.isScalarOrVectorSigned(Type: ResType);
1891 unsigned ConvOp = IsSigned ? SPIRV::OpSConvert : SPIRV::OpUConvert;
1892 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {Sum}, Opcode: ConvOp);
1893}
1894
1895bool SPIRVInstructionSelector::selectPopCount(Register ResVReg,
1896 SPIRVTypeInst ResType,
1897 MachineInstr &I,
1898 unsigned Opcode) const {
1899 // Vulkan restricts OpBitCount to 32-bit integers or vectors of 32-bit
1900 // integers unless VK_KHR_maintenance9 is enabled. Until VK_KHR_maintenance9
1901 // is core we will not generate OpBitCount with any other types when
1902 // targeting Vulkan.
1903 if (!STI.getTargetTriple().isVulkanOS())
1904 return selectUnOp(ResVReg, ResType, I, Opcode);
1905
1906 Register OpReg = I.getOperand(i: 1).getReg();
1907 SPIRVTypeInst OpType = GR.getSPIRVTypeForVReg(VReg: OpReg);
1908 unsigned ExtOpcode = GR.isScalarOrVectorSigned(Type: ResType) ? SPIRV::OpSConvert
1909 : SPIRV::OpUConvert;
1910 switch (GR.getScalarOrVectorBitWidth(Type: OpType)) {
1911 case 8:
1912 case 16:
1913 return selectPopCount16(ResVReg, ResType, I, ExtOpcode, Opcode);
1914 case 32:
1915 return selectPopCount32(ResVReg, ResType, I, SrcReg: OpReg, Opcode);
1916 case 64:
1917 return selectPopCount64(ResVReg, ResType, I, SrcReg: OpReg, Opcode);
1918 default:
1919 return diagnoseUnsupported(I, Msg: "unsupported operand bit width for popcount");
1920 }
1921}
1922
1923bool SPIRVInstructionSelector::selectUnOp(Register ResVReg,
1924 SPIRVTypeInst ResType,
1925 MachineInstr &I,
1926 unsigned Opcode) const {
1927 if (STI.isPhysicalSPIRV() && I.getOperand(i: 1).isReg()) {
1928 Register SrcReg = I.getOperand(i: 1).getReg();
1929 bool IsGV = false;
1930 for (MachineRegisterInfo::def_instr_iterator DefIt =
1931 MRI->def_instr_begin(RegNo: SrcReg);
1932 DefIt != MRI->def_instr_end(); DefIt = std::next(x: DefIt)) {
1933 unsigned DefOpCode = DefIt->getOpcode();
1934 if (DefOpCode == SPIRV::ASSIGN_TYPE || DefOpCode == TargetOpcode::COPY) {
1935 // We need special handling to look through the type assignment or the
1936 // COPY pseudo-op and see if this is a constant or a global.
1937 if (auto *VRD = getVRegDef(MRI&: *MRI, Reg: DefIt->getOperand(i: 1).getReg()))
1938 DefOpCode = VRD->getOpcode();
1939 }
1940 if (DefOpCode == TargetOpcode::G_GLOBAL_VALUE ||
1941 DefOpCode == TargetOpcode::G_CONSTANT ||
1942 DefOpCode == SPIRV::OpVariable ||
1943 DefOpCode == SPIRV::OpUntypedVariableKHR ||
1944 DefOpCode == SPIRV::OpConstantI) {
1945 IsGV = true;
1946 break;
1947 }
1948 }
1949 if (IsGV) {
1950 uint32_t SpecOpcode = 0;
1951 switch (Opcode) {
1952 case SPIRV::OpConvertPtrToU:
1953 SpecOpcode = static_cast<uint32_t>(SPIRV::Opcode::ConvertPtrToU);
1954 break;
1955 case SPIRV::OpConvertUToPtr:
1956 SpecOpcode = static_cast<uint32_t>(SPIRV::Opcode::ConvertUToPtr);
1957 break;
1958 }
1959 if (SpecOpcode) {
1960 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
1961 MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
1962 .addDef(RegNo: ResVReg)
1963 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
1964 .addImm(Val: SpecOpcode)
1965 .addUse(RegNo: SrcReg)
1966 .constrainAllUses(TII, TRI, RBI);
1967 return true;
1968 }
1969 }
1970 }
1971 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {I.getOperand(i: 1).getReg()},
1972 Opcode);
1973}
1974
1975bool SPIRVInstructionSelector::selectBitcast(Register ResVReg,
1976 SPIRVTypeInst ResType,
1977 MachineInstr &I) const {
1978 Register OpReg = I.getOperand(i: 1).getReg();
1979 SPIRVTypeInst OpType =
1980 OpReg.isValid() ? GR.getSPIRVTypeForVReg(VReg: OpReg) : nullptr;
1981 if (!GR.isBitcastCompatible(Type1: ResType, Type2: OpType))
1982 return diagnoseUnsupported(
1983 I, Msg: "incompatible result and operand types in a bitcast");
1984 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpBitcast);
1985}
1986
1987static void
1988addMemoryOperands(const MachineMemOperand *MemOp, MachineInstrBuilder &MIB,
1989 MachineIRBuilder &MIRBuilder, SPIRVGlobalRegistry &GR,
1990 std::optional<Align> AlignOverride = std::nullopt) {
1991 const SPIRVSubtarget *ST =
1992 static_cast<const SPIRVSubtarget *>(&MIRBuilder.getMF().getSubtarget());
1993 uint32_t SpvMemOp = static_cast<uint32_t>(SPIRV::MemoryOperand::None);
1994 if (MemOp->isVolatile())
1995 SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Volatile);
1996 if (MemOp->isNonTemporal())
1997 SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Nontemporal);
1998 // Aligned memory operand requires the Kernel capability.
1999 if (!ST->isShader() && MemOp->getAlign().value())
2000 SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Aligned);
2001
2002 [[maybe_unused]] MachineInstr *AliasList = nullptr;
2003 [[maybe_unused]] MachineInstr *NoAliasList = nullptr;
2004 if (ST->canUseExtension(E: SPIRV::Extension::SPV_INTEL_memory_access_aliasing)) {
2005 if (auto *MD = MemOp->getAAInfo().Scope) {
2006 AliasList = GR.getOrAddMemAliasingINTELInst(MIRBuilder, AliasingListMD: MD);
2007 if (AliasList)
2008 SpvMemOp |=
2009 static_cast<uint32_t>(SPIRV::MemoryOperand::AliasScopeINTELMask);
2010 }
2011 if (auto *MD = MemOp->getAAInfo().NoAlias) {
2012 NoAliasList = GR.getOrAddMemAliasingINTELInst(MIRBuilder, AliasingListMD: MD);
2013 if (NoAliasList)
2014 SpvMemOp |=
2015 static_cast<uint32_t>(SPIRV::MemoryOperand::NoAliasINTELMask);
2016 }
2017 }
2018
2019 if (SpvMemOp != static_cast<uint32_t>(SPIRV::MemoryOperand::None)) {
2020 MIB.addImm(Val: SpvMemOp);
2021 if (SpvMemOp & static_cast<uint32_t>(SPIRV::MemoryOperand::Aligned))
2022 MIB.addImm(Val: AlignOverride.value_or(u: MemOp->getAlign()).value());
2023 if (AliasList)
2024 MIB.addUse(RegNo: AliasList->getOperand(i: 0).getReg());
2025 if (NoAliasList)
2026 MIB.addUse(RegNo: NoAliasList->getOperand(i: 0).getReg());
2027 }
2028}
2029
2030static void addMemoryOperands(uint64_t Flags, MachineInstrBuilder &MIB) {
2031 uint32_t SpvMemOp = static_cast<uint32_t>(SPIRV::MemoryOperand::None);
2032 if (Flags & MachineMemOperand::Flags::MOVolatile)
2033 SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Volatile);
2034 if (Flags & MachineMemOperand::Flags::MONonTemporal)
2035 SpvMemOp |= static_cast<uint32_t>(SPIRV::MemoryOperand::Nontemporal);
2036
2037 if (SpvMemOp != static_cast<uint32_t>(SPIRV::MemoryOperand::None))
2038 MIB.addImm(Val: SpvMemOp);
2039}
2040
2041bool SPIRVInstructionSelector::selectLoad(Register ResVReg,
2042 SPIRVTypeInst ResType,
2043 MachineInstr &I) const {
2044 unsigned OpOffset = isa<GIntrinsic>(Val: I) ? 1 : 0;
2045 Register Ptr = I.getOperand(i: 1 + OpOffset).getReg();
2046
2047 auto *PtrDef = getVRegDef(MRI&: *MRI, Reg: Ptr);
2048 auto *IntPtrDef = dyn_cast<GIntrinsic>(Val: PtrDef);
2049 if (IntPtrDef &&
2050 (IntPtrDef->getIntrinsicID() == Intrinsic::spv_resource_getbasepointer ||
2051 IntPtrDef->getIntrinsicID() == Intrinsic::spv_resource_getpointer)) {
2052
2053 Register HandleReg = IntPtrDef->getOperand(i: 2).getReg();
2054 SPIRVTypeInst HandleType = GR.getSPIRVTypeForVReg(VReg: HandleReg);
2055 if (HandleType->getOpcode() == SPIRV::OpTypeImage) {
2056 Register NewHandleReg =
2057 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: HandleReg));
2058 auto *HandleDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: HandleReg));
2059 if (!loadHandleBeforePosition(HandleReg&: NewHandleReg, ResType: HandleType, HandleDef&: *HandleDef, Pos&: I)) {
2060 return false;
2061 }
2062
2063 Register IdxReg = IntPtrDef->getOperand(i: 3).getReg();
2064 return generateImageReadOrFetch(ResVReg, ResType, ImageReg: NewHandleReg, IdxReg,
2065 Loc: I.getDebugLoc(), Pos&: I);
2066 }
2067 }
2068
2069 MachineIRBuilder MIRBuilder(I);
2070
2071 if (I.getNumMemOperands()) {
2072 const MachineMemOperand *MemOp = *I.memoperands_begin();
2073 if (MemOp->isAtomic())
2074 return selectAtomicLoad(ResVReg, ResType, I);
2075 }
2076
2077 auto MIB = MIRBuilder.buildInstr(Opcode: SPIRV::OpLoad)
2078 .addDef(RegNo: ResVReg)
2079 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2080 .addUse(RegNo: Ptr);
2081 if (!I.getNumMemOperands()) {
2082 assert(I.getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS ||
2083 I.getOpcode() ==
2084 TargetOpcode::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS);
2085 addMemoryOperands(Flags: I.getOperand(i: 2 + OpOffset).getImm(), MIB);
2086 } else {
2087 addMemoryOperands(MemOp: *I.memoperands_begin(), MIB, MIRBuilder, GR);
2088 }
2089 MIB.constrainAllUses(TII, TRI, RBI);
2090 return true;
2091}
2092
2093Register SPIRVInstructionSelector::createPtrSizedIntReg(
2094 MachineIRBuilder &MIRBuilder) const {
2095 SPIRVTypeInst IntType =
2096 GR.getOrCreateSPIRVIntegerType(BitWidth: GR.getPointerSize(), MIRBuilder);
2097 Register Reg =
2098 MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: GR.getPointerSize()));
2099 MRI->setRegClass(Reg, RC: GR.getRegClass(SpvType: IntType));
2100 GR.assignSPIRVTypeToVReg(Type: IntType, VReg: Reg, MF: MIRBuilder.getMF());
2101 return Reg;
2102}
2103
2104Register
2105SPIRVInstructionSelector::convertPtrToInt(Register PtrVal,
2106 MachineIRBuilder &MIRBuilder) const {
2107 SPIRVTypeInst IntType =
2108 GR.getOrCreateSPIRVIntegerType(BitWidth: GR.getPointerSize(), MIRBuilder);
2109 Register IntReg = createPtrSizedIntReg(MIRBuilder);
2110 MIRBuilder.buildInstr(Opcode: SPIRV::OpConvertPtrToU)
2111 .addDef(RegNo: IntReg)
2112 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: IntType)) // Result type
2113 .addUse(RegNo: PtrVal) // Pointer operand
2114 .constrainAllUses(TII, TRI, RBI);
2115 return IntReg;
2116}
2117
2118Register SPIRVInstructionSelector::castPtrToPtrToInt(
2119 Register Ptr, SPIRV::StorageClass::StorageClass SC,
2120 MachineIRBuilder &MIRBuilder) const {
2121 SPIRVTypeInst IntType =
2122 GR.getOrCreateSPIRVIntegerType(BitWidth: GR.getPointerSize(), MIRBuilder);
2123 SPIRVTypeInst PtrType =
2124 GR.getOrCreateSPIRVPointerType(BaseType: IntType, MIRBuilder, SC);
2125 Register CastedPtr =
2126 MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: GR.getPointerSize()));
2127 MRI->setRegClass(Reg: CastedPtr, RC: GR.getRegClass(SpvType: PtrType));
2128 GR.assignSPIRVTypeToVReg(Type: PtrType, VReg: CastedPtr, MF: MIRBuilder.getMF());
2129 MIRBuilder.buildInstr(Opcode: SPIRV::OpBitcast)
2130 .addDef(RegNo: CastedPtr)
2131 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PtrType))
2132 .addUse(RegNo: Ptr)
2133 .constrainAllUses(TII, TRI, RBI);
2134 return CastedPtr;
2135}
2136
2137bool SPIRVInstructionSelector::selectAtomicPtrValue(
2138 Register ResVReg, SPIRVTypeInst ResType, MachineIRBuilder &MIRBuilder,
2139 function_ref<Register(SPIRVTypeInst IntType)> EmitAtomic) const {
2140 // Pointer-typed atomics are lowered by bitcasting the Ptr operand to a
2141 // pointer to an integer of the same size as the pointer, so that the actual
2142 // atomic instruction operates on integers as required by the spec. Value
2143 // operands and results are converted with OpConvertPtrToU/OpConvertUToPtr.
2144 unsigned PtrSize = GR.getPointerSize();
2145 SPIRVTypeInst IntType = GR.getOrCreateSPIRVIntegerType(BitWidth: PtrSize, MIRBuilder);
2146
2147 Register IntResult = EmitAtomic(IntType);
2148 if (IntResult.isValid())
2149 MIRBuilder.buildInstr(Opcode: SPIRV::OpConvertUToPtr)
2150 .addDef(RegNo: ResVReg)
2151 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2152 .addUse(RegNo: IntResult)
2153 .constrainAllUses(TII, TRI, RBI);
2154 return true;
2155}
2156
2157bool SPIRVInstructionSelector::selectAtomicLoad(Register ResVReg,
2158 SPIRVTypeInst ResType,
2159 MachineInstr &I) const {
2160 LLVMContext &Context = I.getMF()->getFunction().getContext();
2161
2162 unsigned OpOffset = isa<GIntrinsic>(Val: I) ? 1 : 0;
2163 Register Ptr = I.getOperand(i: 1 + OpOffset).getReg();
2164
2165 if (!ResType.isTypeIntOrFloat() && !ResType.isTypePtr())
2166 return diagnoseUnsupported(
2167 I, Msg: "Lowering to SPIR-V of atomic load is only "
2168 "allowed for integer, floating point or pointer types");
2169
2170 assert(I.getNumMemOperands());
2171 const MachineMemOperand &MemOp = **I.memoperands_begin();
2172 assert(MemOp.isAtomic());
2173
2174 uint32_t Scope = static_cast<uint32_t>(
2175 getMemScope(TT: STI.getTargetTriple(), Ctx&: Context, Id: MemOp.getSyncScopeID()));
2176 Register ScopeReg = buildI32ConstantInEntryBlock(Val: Scope, I);
2177
2178 AtomicOrdering AO = MemOp.getSuccessOrdering();
2179 uint32_t StorageClass = static_cast<uint32_t>(getMemSemanticsForStorageClass(
2180 SC: addressSpaceToStorageClass(AddrSpace: MemOp.getAddrSpace(), STI)));
2181 uint32_t MemSem = static_cast<uint32_t>(getMemSemantics(Ord: AO));
2182 if (MemOp.isVolatile() && STI.getTargetTriple().isVulkanOS())
2183 MemSem |= static_cast<uint32_t>(SPIRV::MemorySemantics::Volatile);
2184 uint32_t Sem = getMemSemanticsWithStorageClass(TT: STI.getTargetTriple(), OrderSem: MemSem,
2185 StorageClassSem: StorageClass);
2186 Register MemSemReg = buildI32ConstantInEntryBlock(Val: Sem, I);
2187
2188 MachineIRBuilder MIRBuilder(I);
2189
2190 if (ResType.isTypePtr()) {
2191 if (!STI.isPhysicalSPIRV())
2192 return diagnoseUnsupported(
2193 I, Msg: "Lowering to SPIR-V of atomic load is only "
2194 "allowed for pointer types for physical addressing model");
2195 // If data to load is a pointer type we bitcast the Ptr parameter to pointer
2196 // to an integer type of the same size as the pointer size and then generate
2197 // OpAtomicLoad the return value of that OpAtomicLoad is an integer that is
2198 // converted back to a pointer type using OpConvertUToPtr.
2199 SPIRV::StorageClass::StorageClass SC =
2200 addressSpaceToStorageClass(AddrSpace: MemOp.getAddrSpace(), STI);
2201 return selectAtomicPtrValue(
2202 ResVReg, ResType, MIRBuilder, EmitAtomic: [&](SPIRVTypeInst IntType) {
2203 Register CastedPtr = castPtrToPtrToInt(Ptr, SC, MIRBuilder);
2204 Register IntResult = createPtrSizedIntReg(MIRBuilder);
2205 MIRBuilder.buildInstr(Opcode: SPIRV::OpAtomicLoad)
2206 .addDef(RegNo: IntResult)
2207 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: IntType))
2208 .addUse(RegNo: CastedPtr)
2209 .addUse(RegNo: ScopeReg)
2210 .addUse(RegNo: MemSemReg)
2211 .constrainAllUses(TII, TRI, RBI);
2212 return IntResult;
2213 });
2214 }
2215 auto AtomicLoad = MIRBuilder.buildInstr(Opcode: SPIRV::OpAtomicLoad)
2216 .addDef(RegNo: ResVReg)
2217 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2218 .addUse(RegNo: Ptr)
2219 .addUse(RegNo: ScopeReg)
2220 .addUse(RegNo: MemSemReg);
2221 AtomicLoad.constrainAllUses(TII, TRI, RBI);
2222
2223 return true;
2224}
2225
2226bool SPIRVInstructionSelector::selectStore(MachineInstr &I) const {
2227 unsigned OpOffset = isa<GIntrinsic>(Val: I) ? 1 : 0;
2228 Register StoreVal = I.getOperand(i: 0 + OpOffset).getReg();
2229 Register Ptr = I.getOperand(i: 1 + OpOffset).getReg();
2230
2231 auto *PtrDef = getVRegDef(MRI&: *MRI, Reg: Ptr);
2232 auto *IntPtrDef = dyn_cast<GIntrinsic>(Val: PtrDef);
2233 if (IntPtrDef &&
2234 (IntPtrDef->getIntrinsicID() == Intrinsic::spv_resource_getbasepointer ||
2235 IntPtrDef->getIntrinsicID() == Intrinsic::spv_resource_getpointer)) {
2236
2237 Register HandleReg = IntPtrDef->getOperand(i: 2).getReg();
2238 Register NewHandleReg =
2239 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: HandleReg));
2240 auto *HandleDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: HandleReg));
2241 SPIRVTypeInst HandleType = GR.getSPIRVTypeForVReg(VReg: HandleReg);
2242 if (!loadHandleBeforePosition(HandleReg&: NewHandleReg, ResType: HandleType, HandleDef&: *HandleDef, Pos&: I)) {
2243 return false;
2244 }
2245
2246 Register IdxReg = IntPtrDef->getOperand(i: 3).getReg();
2247 if (HandleType->getOpcode() == SPIRV::OpTypeImage) {
2248 SPIRVTypeInst SampledType =
2249 GR.getSPIRVTypeForVReg(VReg: HandleType->getOperand(i: 1).getReg());
2250 SPIRVTypeInst StoreValCompType =
2251 GR.getScalarOrVectorComponentType(Type: GR.getSPIRVTypeForVReg(VReg: StoreVal));
2252 if (StoreValCompType && StoreValCompType != SampledType) {
2253 // A wide element (e.g. int64_t2) is emulated with a narrower packed
2254 // image. This bitcasts the value to match the format.
2255 SPIRVTypeInst PackedType = widenTypeToVec4(Type: SampledType, I);
2256 Register PackedReg =
2257 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: PackedType));
2258 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBitcast))
2259 .addDef(RegNo: PackedReg)
2260 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PackedType))
2261 .addUse(RegNo: StoreVal)
2262 .constrainAllUses(TII, TRI, RBI);
2263 StoreVal = PackedReg;
2264 }
2265
2266 auto BMI = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
2267 MCID: TII.get(Opcode: SPIRV::OpImageWrite))
2268 .addUse(RegNo: NewHandleReg)
2269 .addUse(RegNo: IdxReg)
2270 .addUse(RegNo: StoreVal);
2271
2272 const llvm::Type *LLVMHandleType = GR.getTypeForSPIRVType(Ty: HandleType);
2273 if (sampledTypeIsSignedInteger(HandleType: LLVMHandleType))
2274 BMI.addImm(Val: 0x1000); // SignExtend
2275
2276 BMI.constrainAllUses(TII, TRI, RBI);
2277 return true;
2278 }
2279 }
2280
2281 SPIRVTypeInst PointeeTy = GR.getPointeeType(PtrType: GR.getSPIRVTypeForVReg(VReg: Ptr));
2282 SPIRVTypeInst StoreTy = GR.getSPIRVTypeForVReg(VReg: StoreVal);
2283 if (PointeeTy && PointeeTy->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
2284 StoreTy->getOpcode() != SPIRV::OpTypeVectorIdEXT &&
2285 GR.getScalarOrVectorComponentCount(Type: PointeeTy) == 1) {
2286 MachineInstr *StoreValDef = getVRegDef(MRI&: *MRI, Reg: StoreVal);
2287 Register Reg = StoreValDef->getOperand(i: 0).getReg();
2288 if (auto FC = GFConstant::getConstant(Const: Reg, MRI: *MRI))
2289 StoreVal =
2290 GR.getOrCreateConstVector(Val: FC->getScalarValue(), I, SpvType: PointeeTy, TII);
2291 else if (auto IC = GIConstant::getConstant(Const: Reg, MRI: *MRI))
2292 StoreVal =
2293 GR.getOrCreateConstVector(Val: IC->getScalarValue(), I, SpvType: PointeeTy, TII);
2294 else
2295 llvm_unreachable("Unexpected <1 x T> Store type!");
2296 }
2297
2298 if (I.getNumMemOperands()) {
2299 const MachineMemOperand *MemOp = *I.memoperands_begin();
2300 if (MemOp->isAtomic())
2301 return selectAtomicStore(I);
2302 }
2303
2304 // Stores into a read-only storage class produce invalid SPIR-V. Reject such
2305 // input with a diagnostic rather than silently emitting an OpStore that
2306 // validation rejects.
2307 SPIRV::StorageClass::StorageClass PtrSC = GR.getPointerStorageClass(VReg: Ptr);
2308 if (PtrSC == SPIRV::StorageClass::UniformConstant ||
2309 PtrSC == SPIRV::StorageClass::Input ||
2310 PtrSC == SPIRV::StorageClass::PushConstant)
2311 return diagnoseUnsupported(
2312 I, Msg: "store into a read-only SPIR-V storage class is not allowed");
2313
2314 MachineIRBuilder MIRBuilder(I);
2315 auto MIB = MIRBuilder.buildInstr(Opcode: SPIRV::OpStore).addUse(RegNo: Ptr).addUse(RegNo: StoreVal);
2316 if (!I.getNumMemOperands()) {
2317 assert(I.getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS ||
2318 I.getOpcode() ==
2319 TargetOpcode::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS);
2320 addMemoryOperands(Flags: I.getOperand(i: 2 + OpOffset).getImm(), MIB);
2321 } else {
2322 addMemoryOperands(MemOp: *I.memoperands_begin(), MIB, MIRBuilder, GR);
2323 }
2324 MIB.constrainAllUses(TII, TRI, RBI);
2325 return true;
2326}
2327
2328bool SPIRVInstructionSelector::selectAtomicStore(MachineInstr &I) const {
2329 LLVMContext &Context = I.getMF()->getFunction().getContext();
2330
2331 unsigned OpOffset = isa<GIntrinsic>(Val: I) ? 1 : 0;
2332 Register StoreVal = I.getOperand(i: 0 + OpOffset).getReg();
2333 Register Ptr = I.getOperand(i: 1 + OpOffset).getReg();
2334
2335 SPIRVTypeInst PtrType = GR.getSPIRVTypeForVReg(VReg: Ptr);
2336 SPIRVTypeInst PointeeType = GR.getPointeeType(PtrType);
2337 // For an untyped pointer the data type is the stored value's type.
2338 if (!PointeeType && PtrType &&
2339 PtrType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR)
2340 PointeeType = GR.getSPIRVTypeForVReg(VReg: StoreVal);
2341 if (!PointeeType)
2342 return diagnoseUnsupported(I,
2343 Msg: "Lowering to SPIR-V of atomic store is only "
2344 "allowed for integer or floating point types");
2345
2346 assert(I.getNumMemOperands());
2347 const MachineMemOperand &MemOp = **I.memoperands_begin();
2348 assert(MemOp.isAtomic());
2349
2350 uint32_t Scope = static_cast<uint32_t>(
2351 getMemScope(TT: STI.getTargetTriple(), Ctx&: Context, Id: MemOp.getSyncScopeID()));
2352 Register ScopeReg = buildI32ConstantInEntryBlock(Val: Scope, I);
2353
2354 AtomicOrdering AO = MemOp.getSuccessOrdering();
2355 uint32_t StorageClass = static_cast<uint32_t>(getMemSemanticsForStorageClass(
2356 SC: addressSpaceToStorageClass(AddrSpace: MemOp.getAddrSpace(), STI)));
2357 uint32_t MemSem = static_cast<uint32_t>(getMemSemantics(Ord: AO));
2358 if (MemOp.isVolatile() && STI.getTargetTriple().isVulkanOS())
2359 MemSem |= static_cast<uint32_t>(SPIRV::MemorySemantics::Volatile);
2360 uint32_t Sem = getMemSemanticsWithStorageClass(TT: STI.getTargetTriple(), OrderSem: MemSem,
2361 StorageClassSem: StorageClass);
2362 Register MemSemReg = buildI32ConstantInEntryBlock(Val: Sem, I);
2363 MachineIRBuilder MIRBuilder(I);
2364
2365 if (PointeeType.isTypePtr()) {
2366 if (!STI.isPhysicalSPIRV())
2367 return diagnoseUnsupported(
2368 I, Msg: "Lowering to SPIR-V of atomic store is only "
2369 "allowed for pointer types for physical addressing model");
2370 // If data to store is a pointer type we cast it to an integer type of the
2371 // same size as the pointer size using OpConvertPtrToU, bitcast Ptr
2372 // parameter to pointer to integer type and then generate OpAtomicStore
2373 // with casted values as required by spec.
2374 SPIRV::StorageClass::StorageClass SC =
2375 addressSpaceToStorageClass(AddrSpace: MemOp.getAddrSpace(), STI);
2376 return selectAtomicPtrValue(
2377 ResVReg: Register(), ResType: SPIRVTypeInst(), MIRBuilder, EmitAtomic: [&](SPIRVTypeInst IntType) {
2378 Register ValueAsInt = convertPtrToInt(PtrVal: StoreVal, MIRBuilder);
2379 Register CastedPtr = castPtrToPtrToInt(Ptr, SC, MIRBuilder);
2380 MIRBuilder.buildInstr(Opcode: SPIRV::OpAtomicStore)
2381 .addUse(RegNo: CastedPtr)
2382 .addUse(RegNo: ScopeReg)
2383 .addUse(RegNo: MemSemReg)
2384 .addUse(RegNo: ValueAsInt)
2385 .constrainAllUses(TII, TRI, RBI);
2386 // Stores produce no result, so no OpConvertUToPtr is needed.
2387 return Register();
2388 });
2389 }
2390
2391 if (!PointeeType.isTypeIntOrFloat())
2392 return diagnoseUnsupported(I,
2393 Msg: "Lowering to SPIR-V of atomic store is only "
2394 "allowed for integer or floating point types");
2395
2396 auto AtomicStore = MIRBuilder.buildInstr(Opcode: SPIRV::OpAtomicStore)
2397 .addUse(RegNo: Ptr)
2398 .addUse(RegNo: ScopeReg)
2399 .addUse(RegNo: MemSemReg)
2400 .addUse(RegNo: StoreVal);
2401 AtomicStore.constrainAllUses(TII, TRI, RBI);
2402
2403 return true;
2404}
2405
2406bool SPIRVInstructionSelector::selectMaskedGather(Register ResVReg,
2407 SPIRVTypeInst ResType,
2408 MachineInstr &I) const {
2409 assert(I.getNumExplicitDefs() == 1 && "Expected single def for gather");
2410 // Operand indices:
2411 // 0: result (def)
2412 // 1: intrinsic ID
2413 // 2: vector of pointers
2414 // 3: alignment (i32 immediate)
2415 // 4: mask (vector of i1)
2416 // 5: passthru/fill value
2417 const Register PtrsReg = I.getOperand(i: 2).getReg();
2418 const uint32_t Alignment = I.getOperand(i: 3).getImm();
2419 const Register MaskReg = I.getOperand(i: 4).getReg();
2420 const Register PassthruReg = I.getOperand(i: 5).getReg();
2421 const Register AlignmentReg = buildI32ConstantInEntryBlock(Val: Alignment, I);
2422
2423 MachineBasicBlock &BB = *I.getParent();
2424 auto MIB =
2425 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpMaskedGatherINTEL))
2426 .addDef(RegNo: ResVReg)
2427 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2428 .addUse(RegNo: PtrsReg)
2429 .addUse(RegNo: AlignmentReg)
2430 .addUse(RegNo: MaskReg)
2431 .addUse(RegNo: PassthruReg);
2432 MIB.constrainAllUses(TII, TRI, RBI);
2433 return true;
2434}
2435
2436bool SPIRVInstructionSelector::selectMaskedScatter(MachineInstr &I) const {
2437 assert(I.getNumExplicitDefs() == 0 && "Expected no defs for scatter");
2438 // Operand indices (no explicit defs):
2439 // 0: intrinsic ID
2440 // 1: value vector
2441 // 2: vector of pointers
2442 // 3: alignment (i32 immediate)
2443 // 4: mask (vector of i1)
2444 const Register ValuesReg = I.getOperand(i: 1).getReg();
2445 const Register PtrsReg = I.getOperand(i: 2).getReg();
2446 const uint32_t Alignment = I.getOperand(i: 3).getImm();
2447 const Register MaskReg = I.getOperand(i: 4).getReg();
2448 const Register AlignmentReg = buildI32ConstantInEntryBlock(Val: Alignment, I);
2449 MachineBasicBlock &BB = *I.getParent();
2450
2451 auto MIB =
2452 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpMaskedScatterINTEL))
2453 .addUse(RegNo: PtrsReg)
2454 .addUse(RegNo: AlignmentReg)
2455 .addUse(RegNo: MaskReg)
2456 .addUse(RegNo: ValuesReg);
2457 MIB.constrainAllUses(TII, TRI, RBI);
2458 return true;
2459}
2460
2461bool SPIRVInstructionSelector::diagnoseUnsupported(const MachineInstr &I,
2462 const Twine &Msg) const {
2463 const Function &F = I.getMF()->getFunction();
2464 F.getContext().diagnose(
2465 DI: DiagnosticInfoUnsupported(F, Msg, I.getDebugLoc(), DS_Error));
2466 return false;
2467}
2468
2469bool SPIRVInstructionSelector::selectStackSave(Register ResVReg,
2470 SPIRVTypeInst ResType,
2471 MachineInstr &I) const {
2472 if (!STI.canUseExtension(E: SPIRV::Extension::SPV_INTEL_variable_length_array))
2473 return diagnoseUnsupported(
2474 I, Msg: "llvm.stacksave intrinsic: this instruction requires the following "
2475 "SPIR-V extension: SPV_INTEL_variable_length_array");
2476 MachineBasicBlock &BB = *I.getParent();
2477 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSaveMemoryINTEL))
2478 .addDef(RegNo: ResVReg)
2479 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2480 .constrainAllUses(TII, TRI, RBI);
2481 return true;
2482}
2483
2484bool SPIRVInstructionSelector::selectStackRestore(MachineInstr &I) const {
2485 if (!STI.canUseExtension(E: SPIRV::Extension::SPV_INTEL_variable_length_array))
2486 return diagnoseUnsupported(
2487 I,
2488 Msg: "llvm.stackrestore intrinsic: this instruction requires the following "
2489 "SPIR-V extension: SPV_INTEL_variable_length_array");
2490 if (!I.getOperand(i: 0).isReg())
2491 return false;
2492 MachineBasicBlock &BB = *I.getParent();
2493 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpRestoreMemoryINTEL))
2494 .addUse(RegNo: I.getOperand(i: 0).getReg())
2495 .constrainAllUses(TII, TRI, RBI);
2496 return true;
2497}
2498
2499Register
2500SPIRVInstructionSelector::getOrCreateMemSetGlobal(MachineInstr &I) const {
2501 MachineIRBuilder MIRBuilder(I);
2502 assert(I.getOperand(1).isReg() && I.getOperand(2).isReg());
2503
2504 // TODO: check if we have such GV, add init, use buildGlobalVariable.
2505 unsigned Num = getIConstVal(ConstReg: I.getOperand(i: 2).getReg(), MRI);
2506 Function &CurFunction = GR.CurMF->getFunction();
2507 Type *LLVMArrTy =
2508 ArrayType::get(ElementType: IntegerType::get(C&: CurFunction.getContext(), NumBits: 8), NumElements: Num);
2509 GlobalVariable *GV = new GlobalVariable(*CurFunction.getParent(), LLVMArrTy,
2510 true, GlobalValue::InternalLinkage,
2511 Constant::getNullValue(Ty: LLVMArrTy));
2512
2513 Type *ValTy = Type::getInt8Ty(C&: I.getMF()->getFunction().getContext());
2514 Type *ArrTy = ArrayType::get(ElementType: ValTy, NumElements: Num);
2515 SPIRVTypeInst VarTy = GR.getOrCreateSPIRVPointerType(
2516 BaseType: ArrTy, MIRBuilder, SC: SPIRV::StorageClass::UniformConstant);
2517
2518 SPIRVTypeInst SpvArrTy = GR.getOrCreateSPIRVType(
2519 Type: ArrTy, MIRBuilder, AQ: SPIRV::AccessQualifier::None, EmitIR: false);
2520
2521 unsigned Val = getIConstVal(ConstReg: I.getOperand(i: 1).getReg(), MRI);
2522 Register Const = GR.getOrCreateConstIntArray(Val, Num, I, SpvType: SpvArrTy, TII);
2523
2524 Register VarReg = MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: 64));
2525 // With SPV_KHR_untyped_pointers enabled, getOrCreateSPIRVPointerType returns
2526 // an untyped pointer type. An untyped pointer result type is only legal on
2527 // OpUntypedVariableKHR, not on OpVariable.
2528 // Pick the matching opcode/operands so the synthesized constant global is
2529 // valid SPIR-V.
2530 const bool IsUntyped = VarTy->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
2531 auto MIBVar = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
2532 MCID: TII.get(Opcode: IsUntyped ? SPIRV::OpUntypedVariableKHR
2533 : SPIRV::OpVariable))
2534 .addDef(RegNo: VarReg)
2535 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: VarTy))
2536 .addImm(Val: SPIRV::StorageClass::UniformConstant);
2537 if (IsUntyped)
2538 MIBVar.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SpvArrTy)); // Data Type
2539 MIBVar.addUse(RegNo: Const); // Initializer
2540 MIBVar.constrainAllUses(TII, TRI, RBI);
2541
2542 GR.add(V: GV, MI: MIBVar);
2543 GR.addGlobalObject(V: GV, MF: GR.CurMF, R: VarReg);
2544
2545 buildOpDecorate(Reg: VarReg, I, TII, Dec: SPIRV::Decoration::Constant, DecArgs: {});
2546 return VarReg;
2547}
2548
2549bool SPIRVInstructionSelector::selectCopyMemory(MachineInstr &I,
2550 Register SrcReg) const {
2551 MachineBasicBlock &BB = *I.getParent();
2552 Register DstReg = I.getOperand(i: 0).getReg();
2553 const bool IsLogical = STI.isLogicalSPIRV();
2554 if (IsLogical) {
2555 SPIRVTypeInst DstTy = GR.getSPIRVTypeForVReg(VReg: DstReg);
2556 SPIRVTypeInst SrcTy = GR.getSPIRVTypeForVReg(VReg: SrcReg);
2557 if (GR.getPointeeType(PtrType: DstTy) != GR.getPointeeType(PtrType: SrcTy))
2558 return diagnoseUnsupported(
2559 I, Msg: "OpCopyMemory requires operands to have the same type");
2560 uint64_t CopySize = getIConstVal(ConstReg: I.getOperand(i: 2).getReg(), MRI);
2561 SPIRVTypeInst PointeeTy = GR.getPointeeType(PtrType: DstTy);
2562 const Type *LLVMPointeeTy = GR.getTypeForSPIRVType(Ty: PointeeTy);
2563 if (!LLVMPointeeTy)
2564 return diagnoseUnsupported(
2565 I, Msg: "Unable to determine pointee type size for OpCopyMemory");
2566 const DataLayout &DL = I.getMF()->getFunction().getDataLayout();
2567 if (CopySize != DL.getTypeStoreSize(Ty: const_cast<Type *>(LLVMPointeeTy)))
2568 return diagnoseUnsupported(
2569 I, Msg: "OpCopyMemory requires the size to match the pointee type size");
2570 }
2571
2572 const unsigned Opcode =
2573 IsLogical ? SPIRV::OpCopyMemory : SPIRV::OpCopyMemorySized;
2574 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
2575 .addUse(RegNo: DstReg)
2576 .addUse(RegNo: SrcReg);
2577 if (!IsLogical)
2578 MIB.addUse(RegNo: I.getOperand(i: 2).getReg());
2579
2580 if (I.getNumMemOperands()) {
2581 MachineIRBuilder MIRBuilder(I);
2582 const MachineMemOperand *DstMemOp = *I.memoperands_begin();
2583 const Align DstAlign = DstMemOp->getAlign();
2584 Align SrcAlign = DstAlign;
2585 // Copies carry destination and source MMOs; memset carries only the
2586 // destination. Shader memory operands do not include alignment.
2587 if (I.getNumMemOperands() > 1 && !STI.isShader())
2588 SrcAlign = (*std::next(x: I.memoperands_begin()))->getAlign();
2589
2590 // A single mask applies to both pointers. SPIR-V 1.4 allows separate
2591 // destination and source masks, preserving their individual alignments.
2592 if (DstAlign != SrcAlign && STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 4))) {
2593 // Preserve the existing flags and metadata on both accesses.
2594 addMemoryOperands(MemOp: DstMemOp, MIB, MIRBuilder, GR);
2595 addMemoryOperands(MemOp: DstMemOp, MIB, MIRBuilder, GR, AlignOverride: SrcAlign);
2596 } else {
2597 addMemoryOperands(MemOp: DstMemOp, MIB, MIRBuilder, GR,
2598 AlignOverride: std::min(a: DstAlign, b: SrcAlign));
2599 }
2600 }
2601 MIB.constrainAllUses(TII, TRI, RBI);
2602 return true;
2603}
2604
2605bool SPIRVInstructionSelector::selectMemOperation(Register ResVReg,
2606 MachineInstr &I) const {
2607 // Zero-sized memcpy/memmove/memset are no-ops.
2608 Register SizeReg = I.getOperand(i: 2).getReg();
2609 if (MachineInstr *SizeDef = getDefInstrMaybeConstant(ConstReg&: SizeReg, MRI);
2610 SizeDef && SizeDef->getOpcode() == TargetOpcode::G_CONSTANT &&
2611 getIConstVal(ConstReg: SizeReg, MRI) == 0)
2612 return true;
2613
2614 Register SrcReg = I.getOperand(i: 1).getReg();
2615 if (I.getOpcode() == TargetOpcode::G_MEMSET ||
2616 I.getOpcode() == TargetOpcode::G_MEMSET_INLINE) {
2617 Register VarReg = getOrCreateMemSetGlobal(I);
2618 if (!VarReg.isValid())
2619 return false;
2620 Type *ValTy = Type::getInt8Ty(C&: I.getMF()->getFunction().getContext());
2621 SPIRVTypeInst SourceTy = GR.getOrCreateSPIRVPointerType(
2622 BaseType: ValTy, I, SC: SPIRV::StorageClass::UniformConstant);
2623 SrcReg = MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: 64));
2624 if (!selectOpWithSrcs(ResVReg: SrcReg, ResType: SourceTy, I, Srcs: {VarReg}, Opcode: SPIRV::OpBitcast))
2625 return false;
2626 }
2627 if (!selectCopyMemory(I, SrcReg))
2628 return false;
2629 if (ResVReg.isValid() && ResVReg != I.getOperand(i: 0).getReg())
2630 if (!BuildCOPY(DestReg: ResVReg, SrcReg: I.getOperand(i: 0).getReg(), I))
2631 return false;
2632 return true;
2633}
2634
2635bool SPIRVInstructionSelector::selectAtomicRMW(Register ResVReg,
2636 SPIRVTypeInst ResType,
2637 MachineInstr &I,
2638 unsigned NewOpcode,
2639 unsigned NegateOpcode) const {
2640 assert(I.hasOneMemOperand());
2641 const MachineMemOperand *MemOp = *I.memoperands_begin();
2642 uint32_t Scope = static_cast<uint32_t>(
2643 getMemScope(TT: STI.getTargetTriple(), Ctx&: GR.CurMF->getFunction().getContext(),
2644 Id: MemOp->getSyncScopeID()));
2645 Register ScopeReg = buildI32ConstantInEntryBlock(Val: Scope, I);
2646
2647 Register Ptr = I.getOperand(i: 1).getReg();
2648 uint32_t ScSem = static_cast<uint32_t>(
2649 getMemSemanticsForStorageClass(SC: GR.getPointerStorageClass(VReg: Ptr)));
2650 AtomicOrdering AO = MemOp->getSuccessOrdering();
2651 uint32_t OrderSem = static_cast<uint32_t>(getMemSemantics(Ord: AO));
2652 Register MemSemReg = buildI32ConstantInEntryBlock(
2653 Val: getMemSemanticsWithStorageClass(TT: STI.getTargetTriple(), OrderSem, StorageClassSem: ScSem),
2654 I);
2655
2656 Register ValueReg = I.getOperand(i: 2).getReg();
2657 if (NegateOpcode != 0) {
2658 // Translation with negative value operand is requested
2659 Register TmpReg = createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: MRI->getMF());
2660 if (!selectOpWithSrcs(ResVReg: TmpReg, ResType, I, Srcs: {ValueReg}, Opcode: NegateOpcode))
2661 return false;
2662 ValueReg = TmpReg;
2663 }
2664
2665 if (ResType.isTypePtr()) {
2666 if (NewOpcode != SPIRV::OpAtomicExchange)
2667 return diagnoseUnsupported(
2668 I, Msg: "Lowering to SPIR-V of this atomic operation is not "
2669 "allowed for pointer types");
2670 if (!STI.isPhysicalSPIRV())
2671 return diagnoseUnsupported(
2672 I, Msg: "Lowering to SPIR-V of atomic exchange is only "
2673 "allowed for pointer types for physical addressing model");
2674 // If the exchanged value is a pointer type we convert the value operand to
2675 // an integer type of the same size as the pointer size using
2676 // OpConvertPtrToU, bitcast the Ptr parameter to pointer to integer type and
2677 // then generate OpAtomicExchange on integers. The integer result is
2678 // converted back to a pointer type using OpConvertUToPtr, similar to atomic
2679 // load and store.
2680 MachineIRBuilder MIRBuilder(I);
2681 SPIRV::StorageClass::StorageClass SC = GR.getPointerStorageClass(VReg: Ptr);
2682 return selectAtomicPtrValue(
2683 ResVReg, ResType, MIRBuilder, EmitAtomic: [&](SPIRVTypeInst IntType) {
2684 Register ValueAsInt = convertPtrToInt(PtrVal: ValueReg, MIRBuilder);
2685 Register CastedPtr = castPtrToPtrToInt(Ptr, SC, MIRBuilder);
2686 Register ExchangeResReg = createPtrSizedIntReg(MIRBuilder);
2687 MIRBuilder.buildInstr(Opcode: SPIRV::OpAtomicExchange)
2688 .addDef(RegNo: ExchangeResReg)
2689 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: IntType))
2690 .addUse(RegNo: CastedPtr)
2691 .addUse(RegNo: ScopeReg)
2692 .addUse(RegNo: MemSemReg)
2693 .addUse(RegNo: ValueAsInt)
2694 .constrainAllUses(TII, TRI, RBI);
2695 return ExchangeResReg;
2696 });
2697 }
2698
2699 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: NewOpcode))
2700 .addDef(RegNo: ResVReg)
2701 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2702 .addUse(RegNo: Ptr)
2703 .addUse(RegNo: ScopeReg)
2704 .addUse(RegNo: MemSemReg)
2705 .addUse(RegNo: ValueReg)
2706 .constrainAllUses(TII, TRI, RBI);
2707 return true;
2708}
2709
2710bool SPIRVInstructionSelector::selectUnmergeValues(MachineInstr &I) const {
2711 unsigned ArgI = I.getNumOperands() - 1;
2712 Register SrcReg =
2713 I.getOperand(i: ArgI).isReg() ? I.getOperand(i: ArgI).getReg() : Register(0);
2714 SPIRVTypeInst SrcType =
2715 SrcReg.isValid() ? GR.getSPIRVTypeForVReg(VReg: SrcReg) : nullptr;
2716 if (!SrcType || !isVectorType(SPVTy: SrcType))
2717 report_fatal_error(
2718 reason: "cannot select G_UNMERGE_VALUES with a non-vector argument");
2719
2720 SPIRVTypeInst ScalarType = GR.getScalarOrVectorComponentType(Type: SrcType);
2721 MachineBasicBlock &BB = *I.getParent();
2722 unsigned CurrentIndex = 0;
2723 for (unsigned i = 0; i < I.getNumDefs(); ++i) {
2724 Register ResVReg = I.getOperand(i).getReg();
2725 SPIRVTypeInst ResType = GR.getSPIRVTypeForVReg(VReg: ResVReg);
2726 if (!ResType) {
2727 LLT ResLLT = MRI->getType(Reg: ResVReg);
2728 assert(ResLLT.isValid());
2729 if (ResLLT.isVector()) {
2730 ResType = GR.getOrCreateSPIRVVectorType(
2731 BaseType: ScalarType, NumElements: ResLLT.getNumElements(), I, TII);
2732 } else {
2733 ResType = ScalarType;
2734 }
2735 MRI->setRegClass(Reg: ResVReg, RC: GR.getRegClass(SpvType: ResType));
2736 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: ResVReg, MF: *GR.CurMF);
2737 }
2738
2739 if (isVectorType(SPVTy: ResType)) {
2740 Register UndefReg = GR.getOrCreateUndef(I, SpvType: SrcType, TII);
2741 auto MIB =
2742 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
2743 .addDef(RegNo: ResVReg)
2744 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2745 .addUse(RegNo: SrcReg)
2746 .addUse(RegNo: UndefReg);
2747 unsigned NumElements = GR.getScalarOrVectorComponentCount(Type: ResType);
2748 for (unsigned j = 0; j < NumElements; ++j) {
2749 MIB.addImm(Val: CurrentIndex + j);
2750 }
2751 CurrentIndex += NumElements;
2752 MIB.constrainAllUses(TII, TRI, RBI);
2753 } else {
2754 auto MIB =
2755 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
2756 .addDef(RegNo: ResVReg)
2757 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2758 .addUse(RegNo: SrcReg)
2759 .addImm(Val: CurrentIndex);
2760 CurrentIndex++;
2761 MIB.constrainAllUses(TII, TRI, RBI);
2762 }
2763 }
2764 return true;
2765}
2766
2767bool SPIRVInstructionSelector::selectFence(MachineInstr &I) const {
2768 AtomicOrdering AO = AtomicOrdering(I.getOperand(i: 0).getImm());
2769 // In the kernel environment image ordering is requested explicitly via
2770 // CLK_IMAGE_MEM_FENCE, so a fence covers only pointer-addressable memory.
2771 uint32_t ScSem = STI.isShader()
2772 ? SPIRV::MemorySemantics::UniformMemory |
2773 SPIRV::MemorySemantics::WorkgroupMemory |
2774 SPIRV::MemorySemantics::ImageMemory
2775 : SPIRV::MemorySemantics::WorkgroupMemory |
2776 SPIRV::MemorySemantics::CrossWorkgroupMemory;
2777 uint32_t MemSem = getMemSemanticsWithStorageClass(
2778 TT: STI.getTargetTriple(), OrderSem: static_cast<uint32_t>(getMemSemantics(Ord: AO)), StorageClassSem: ScSem);
2779 Register MemSemReg = buildI32ConstantInEntryBlock(Val: MemSem, I);
2780 SyncScope::ID Ord = SyncScope::ID(I.getOperand(i: 1).getImm());
2781 uint32_t Scope = static_cast<uint32_t>(getMemScope(
2782 TT: STI.getTargetTriple(), Ctx&: GR.CurMF->getFunction().getContext(), Id: Ord));
2783 Register ScopeReg = buildI32ConstantInEntryBlock(Val: Scope, I);
2784 MachineBasicBlock &BB = *I.getParent();
2785 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpMemoryBarrier))
2786 .addUse(RegNo: ScopeReg)
2787 .addUse(RegNo: MemSemReg)
2788 .constrainAllUses(TII, TRI, RBI);
2789 return true;
2790}
2791
2792bool SPIRVInstructionSelector::selectOverflowArith(Register ResVReg,
2793 SPIRVTypeInst ResType,
2794 MachineInstr &I,
2795 unsigned Opcode) const {
2796 Type *ResTy = nullptr;
2797 StringRef ResName;
2798 if (!GR.findValueAttrs(Key: &I, Ty&: ResTy, Name&: ResName))
2799 return diagnoseUnsupported(
2800 I,
2801 Msg: "Not enough info to select the arithmetic with overflow instruction");
2802 if (!ResTy || !ResTy->isStructTy())
2803 return diagnoseUnsupported(I,
2804 Msg: "Expect struct type result for the arithmetic "
2805 "with overflow instruction");
2806 // "Result Type must be from OpTypeStruct. The struct must have two members,
2807 // and the two members must be the same type."
2808 Type *ResElemTy = cast<StructType>(Val: ResTy)->getElementType(N: 0);
2809 ResTy = StructType::get(elt1: ResElemTy, elts: ResElemTy);
2810 // Build SPIR-V types and constant(s) if needed.
2811 MachineIRBuilder MIRBuilder(I);
2812 SPIRVTypeInst StructType = GR.getOrCreateSPIRVType(
2813 Type: ResTy, MIRBuilder, AQ: SPIRV::AccessQualifier::ReadWrite, EmitIR: false);
2814 assert(I.getNumDefs() > 1 && "Not enought operands");
2815 SPIRVTypeInst BoolType = GR.getOrCreateSPIRVBoolType(I, TII);
2816 unsigned N = GR.getScalarOrVectorComponentCount(Type: ResType);
2817 if (N > 1 || (isVectorType(SPVTy: ResType) &&
2818 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector)))
2819 BoolType = GR.getOrCreateSPIRVVectorType(BaseType: BoolType, NumElements: N, I, TII);
2820 Register BoolTypeReg = GR.getSPIRVTypeID(SpirvType: BoolType);
2821 Register ZeroReg = buildZerosVal(ResType, I);
2822 // A new virtual register to store the result struct.
2823 Register StructVReg = MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: 64));
2824 MRI->setRegClass(Reg: StructVReg, RC: &SPIRV::IDRegClass);
2825 // Build the result name if needed.
2826 if (ResName.size() > 0)
2827 buildOpName(Target: StructVReg, Name: ResName, MIRBuilder);
2828 // Build the arithmetic with overflow instruction.
2829 MachineBasicBlock &BB = *I.getParent();
2830 auto MIB =
2831 BuildMI(BB, I: MIRBuilder.getInsertPt(), MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
2832 .addDef(RegNo: StructVReg)
2833 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: StructType));
2834 for (unsigned i = I.getNumDefs(); i < I.getNumOperands(); ++i)
2835 MIB.addUse(RegNo: I.getOperand(i).getReg());
2836 MIB.constrainAllUses(TII, TRI, RBI);
2837 // Build instructions to extract fields of the instruction's result.
2838 // A new virtual register to store the higher part of the result struct.
2839 Register HigherVReg = MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: 64));
2840 MRI->setRegClass(Reg: HigherVReg, RC: &SPIRV::iIDRegClass);
2841 for (unsigned i = 0; i < I.getNumDefs(); ++i) {
2842 auto MIB =
2843 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
2844 .addDef(RegNo: i == 1 ? HigherVReg : I.getOperand(i).getReg())
2845 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2846 .addUse(RegNo: StructVReg)
2847 .addImm(Val: i);
2848 MIB.constrainAllUses(TII, TRI, RBI);
2849 }
2850 // Build boolean value from the higher part.
2851 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpINotEqual))
2852 .addDef(RegNo: I.getOperand(i: 1).getReg())
2853 .addUse(RegNo: BoolTypeReg)
2854 .addUse(RegNo: HigherVReg)
2855 .addUse(RegNo: ZeroReg)
2856 .constrainAllUses(TII, TRI, RBI);
2857 return true;
2858}
2859
2860bool SPIRVInstructionSelector::selectAtomicCmpXchg(Register ResVReg,
2861 SPIRVTypeInst ResType,
2862 MachineInstr &I) const {
2863 assert(isa<GIntrinsic>(I) &&
2864 "selectAtomicCmpXchg only handles the spv_cmpxchg intrinsic");
2865 Register Ptr = I.getOperand(i: 2).getReg();
2866 Register ScopeReg = I.getOperand(i: 5).getReg();
2867 Register MemSemEqReg = I.getOperand(i: 6).getReg();
2868 Register MemSemNeqReg = I.getOperand(i: 7).getReg();
2869 Register Cmp = I.getOperand(i: 3).getReg();
2870 Register Val = I.getOperand(i: 4).getReg();
2871 SPIRVTypeInst SpvValTy = GR.getSPIRVTypeForVReg(VReg: Val);
2872 Register ACmpRes = createVirtualRegister(SpvType: SpvValTy, GR: &GR, MRI, MF: *I.getMF());
2873 const DebugLoc &DL = I.getDebugLoc();
2874 BuildMI(BB&: *I.getParent(), I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpAtomicCompareExchange))
2875 .addDef(RegNo: ACmpRes)
2876 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SpvValTy))
2877 .addUse(RegNo: Ptr)
2878 .addUse(RegNo: ScopeReg)
2879 .addUse(RegNo: MemSemEqReg)
2880 .addUse(RegNo: MemSemNeqReg)
2881 .addUse(RegNo: Val)
2882 .addUse(RegNo: Cmp)
2883 .constrainAllUses(TII, TRI, RBI);
2884 SPIRVTypeInst BoolTy = GR.getOrCreateSPIRVBoolType(I, TII);
2885 Register CmpSuccReg = createVirtualRegister(SpvType: BoolTy, GR: &GR, MRI, MF: *I.getMF());
2886 BuildMI(BB&: *I.getParent(), I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpIEqual))
2887 .addDef(RegNo: CmpSuccReg)
2888 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: BoolTy))
2889 .addUse(RegNo: ACmpRes)
2890 .addUse(RegNo: Cmp)
2891 .constrainAllUses(TII, TRI, RBI);
2892 Register TmpReg = createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: *I.getMF());
2893 BuildMI(BB&: *I.getParent(), I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpCompositeInsert))
2894 .addDef(RegNo: TmpReg)
2895 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2896 .addUse(RegNo: ACmpRes)
2897 .addUse(RegNo: GR.getOrCreateUndef(I, SpvType: ResType, TII))
2898 .addImm(Val: 0)
2899 .constrainAllUses(TII, TRI, RBI);
2900 BuildMI(BB&: *I.getParent(), I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpCompositeInsert))
2901 .addDef(RegNo: ResVReg)
2902 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
2903 .addUse(RegNo: CmpSuccReg)
2904 .addUse(RegNo: TmpReg)
2905 .addImm(Val: 1)
2906 .constrainAllUses(TII, TRI, RBI);
2907 return true;
2908}
2909
2910static bool isUSMStorageClass(SPIRV::StorageClass::StorageClass SC) {
2911 switch (SC) {
2912 case SPIRV::StorageClass::DeviceOnlyINTEL:
2913 case SPIRV::StorageClass::HostOnlyINTEL:
2914 return true;
2915 default:
2916 return false;
2917 }
2918}
2919
2920// Returns true ResVReg is referred only from global vars, constant expressions
2921// and OpName's.
2922static bool isASCastInGVar(MachineRegisterInfo *MRI, Register ResVReg) {
2923 bool IsGRef = false;
2924 bool IsAllowedRefs =
2925 llvm::all_of(Range: MRI->use_instructions(Reg: ResVReg), P: [&IsGRef](auto const &It) {
2926 unsigned Opcode = It.getOpcode();
2927 if (Opcode == SPIRV::OpConstantComposite ||
2928 Opcode == SPIRV::OpSpecConstantComposite ||
2929 Opcode == SPIRV::OpSpecConstantOp || Opcode == SPIRV::OpVariable ||
2930 Opcode == SPIRV::OpUntypedVariableKHR ||
2931 isSpvIntrinsic(It, Intrinsic::spv_init_global))
2932 return IsGRef = true;
2933 return Opcode == SPIRV::OpName;
2934 });
2935 return IsAllowedRefs && IsGRef;
2936}
2937
2938SPIRVTypeInst SPIRVInstructionSelector::getUcharPtrType(
2939 MachineInstr &I, SPIRV::StorageClass::StorageClass SC) const {
2940 return GR.getOrCreateSPIRVPointerType(
2941 BaseType: Type::getInt8Ty(C&: I.getMF()->getFunction().getContext()), I, SC);
2942}
2943
2944Register SPIRVInstructionSelector::getUcharPtrTypeReg(
2945 MachineInstr &I, SPIRV::StorageClass::StorageClass SC) const {
2946 return GR.getSPIRVTypeID(SpirvType: getUcharPtrType(I, SC));
2947}
2948
2949MachineInstrBuilder
2950SPIRVInstructionSelector::buildSpecConstantOp(MachineInstr &I, Register Dest,
2951 Register Src, Register DestType,
2952 uint32_t Opcode) const {
2953 return BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
2954 MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
2955 .addDef(RegNo: Dest)
2956 .addUse(RegNo: DestType)
2957 .addImm(Val: Opcode)
2958 .addUse(RegNo: Src);
2959}
2960
2961// Bitcast a constant pointer to i8* in its own storage class. Src is returned
2962// unchanged when it is already that pointer, or is not a pointer.
2963Register SPIRVInstructionSelector::bitcastConstPtrToI8(MachineInstr &I,
2964 Register Src) const {
2965 SPIRVTypeInst SrcTy = GR.getSPIRVTypeForVReg(VReg: Src);
2966 if (!SrcTy || !SrcTy.isPointer())
2967 return Src;
2968 SPIRVTypeInst I8Ty = getUcharPtrType(I, SC: GR.getPointerStorageClass(Type: SrcTy));
2969 if (SrcTy == I8Ty)
2970 return Src;
2971 Register Tmp = createVirtualRegister(SpvType: I8Ty, GR: &GR, MRI, MF: *I.getMF());
2972 MachineInstrBuilder Cast =
2973 buildSpecConstantOp(I, Dest: Tmp, Src, DestType: GR.getSPIRVTypeID(SpirvType: I8Ty),
2974 Opcode: static_cast<uint32_t>(SPIRV::Opcode::Bitcast));
2975 GR.add(Obj: Cast.getInstr(), MI: Cast);
2976 Cast.constrainAllUses(TII, TRI, RBI);
2977 return Tmp;
2978}
2979
2980MachineInstrBuilder
2981SPIRVInstructionSelector::buildConstGenericPtr(MachineInstr &I, Register SrcPtr,
2982 SPIRVTypeInst SrcPtrTy) const {
2983 SPIRVTypeInst GenericPtrTy =
2984 GR.changePointerStorageClass(PtrType: SrcPtrTy, SC: SPIRV::StorageClass::Generic, I);
2985 Register Tmp = MRI->createVirtualRegister(RegClass: &SPIRV::pIDRegClass);
2986 MRI->setType(VReg: Tmp, Ty: LLT::pointer(AddressSpace: storageClassToAddressSpace(
2987 SC: SPIRV::StorageClass::Generic),
2988 SizeInBits: GR.getPointerSize()));
2989 MachineFunction *MF = I.getParent()->getParent();
2990 GR.assignSPIRVTypeToVReg(Type: GenericPtrTy, VReg: Tmp, MF: *MF);
2991 MachineInstrBuilder MIB = buildSpecConstantOp(
2992 I, Dest: Tmp, Src: SrcPtr, DestType: GR.getSPIRVTypeID(SpirvType: GenericPtrTy),
2993 Opcode: static_cast<uint32_t>(SPIRV::Opcode::PtrCastToGeneric));
2994 GR.add(Obj: MIB.getInstr(), MI: MIB);
2995 return MIB;
2996}
2997
2998// In SPIR-V address space casting can only happen to and from the Generic
2999// storage class. We can also only cast Workgroup, CrossWorkgroup, or Function
3000// pointers to and from Generic pointers. As such, we can convert e.g. from
3001// Workgroup to Function by going via a Generic pointer as an intermediary. All
3002// other combinations can only be done by a bitcast, and are probably not safe.
3003bool SPIRVInstructionSelector::selectAddrSpaceCast(Register ResVReg,
3004 SPIRVTypeInst ResType,
3005 MachineInstr &I) const {
3006 MachineBasicBlock &BB = *I.getParent();
3007 const DebugLoc &DL = I.getDebugLoc();
3008
3009 Register SrcPtr = I.getOperand(i: 1).getReg();
3010 SPIRVTypeInst SrcPtrTy = GR.getSPIRVTypeForVReg(VReg: SrcPtr);
3011
3012 // don't generate a cast for a null that may be represented by OpTypeInt
3013 if (!SrcPtrTy || !SrcPtrTy.isPointer() || !ResType || !ResType.isPointer())
3014 return BuildCOPY(DestReg: ResVReg, SrcReg: SrcPtr, I);
3015
3016 SPIRV::StorageClass::StorageClass SrcSC = GR.getPointerStorageClass(Type: SrcPtrTy);
3017 SPIRV::StorageClass::StorageClass DstSC = GR.getPointerStorageClass(Type: ResType);
3018
3019 if (isASCastInGVar(MRI, ResVReg)) {
3020 // AddrSpaceCast uses within OpVariable and OpConstantComposite instructions
3021 // are expressed by OpSpecConstantOp with an Opcode.
3022 // TODO: maybe insert a check whether the Kernel capability was declared and
3023 // so PtrCastToGeneric/GenericCastToPtr are available.
3024 unsigned SpecOpcode = [&]() -> unsigned {
3025 if (SrcSC == SPIRV::StorageClass::CodeSectionINTEL)
3026 return static_cast<uint32_t>(SPIRV::Opcode::Bitcast);
3027 if (DstSC == SPIRV::StorageClass::Generic && isGenericCastablePtr(SC: SrcSC))
3028 return static_cast<uint32_t>(SPIRV::Opcode::PtrCastToGeneric);
3029 if (SrcSC == SPIRV::StorageClass::Generic && isGenericCastablePtr(SC: DstSC))
3030 return static_cast<uint32_t>(SPIRV::Opcode::GenericCastToPtr);
3031 return 0u;
3032 }();
3033 // TODO: OpConstantComposite expects i8*, so we are forced to forget a
3034 // correct value of ResType and use general i8* instead. Maybe this should
3035 // be addressed in the emit-intrinsic step to infer a correct
3036 // OpConstantComposite type.
3037 // Generic casts require matching pointee types, so cast the source to i8*
3038 // too, but only if a cast is emitted below.
3039 bool ViaGeneric =
3040 isGenericCastablePtr(SC: SrcSC) && isGenericCastablePtr(SC: DstSC);
3041 if (SrcSC != SPIRV::StorageClass::CodeSectionINTEL &&
3042 (SpecOpcode || ViaGeneric)) {
3043 SrcPtr = bitcastConstPtrToI8(I, Src: SrcPtr);
3044 SrcPtrTy = GR.getSPIRVTypeForVReg(VReg: SrcPtr);
3045 }
3046 if (SpecOpcode) {
3047 buildSpecConstantOp(I, Dest: ResVReg, Src: SrcPtr, DestType: getUcharPtrTypeReg(I, SC: DstSC),
3048 Opcode: SpecOpcode)
3049 .constrainAllUses(TII, TRI, RBI);
3050 } else if (ViaGeneric) {
3051 MachineInstrBuilder MIB = buildConstGenericPtr(I, SrcPtr, SrcPtrTy);
3052 MIB.constrainAllUses(TII, TRI, RBI);
3053 buildSpecConstantOp(
3054 I, Dest: ResVReg, Src: MIB->getOperand(i: 0).getReg(), DestType: getUcharPtrTypeReg(I, SC: DstSC),
3055 Opcode: static_cast<uint32_t>(SPIRV::Opcode::GenericCastToPtr))
3056 .constrainAllUses(TII, TRI, RBI);
3057 }
3058 return true;
3059 }
3060
3061 // don't generate a cast between identical storage classes
3062 if (SrcSC == DstSC)
3063 return BuildCOPY(DestReg: ResVReg, SrcReg: SrcPtr, I);
3064
3065 if ((SrcSC == SPIRV::StorageClass::Function &&
3066 DstSC == SPIRV::StorageClass::Private) ||
3067 (DstSC == SPIRV::StorageClass::Function &&
3068 SrcSC == SPIRV::StorageClass::Private))
3069 return BuildCOPY(DestReg: ResVReg, SrcReg: SrcPtr, I);
3070
3071 // Casting from an eligible pointer to Generic.
3072 if (DstSC == SPIRV::StorageClass::Generic && isGenericCastablePtr(SC: SrcSC))
3073 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpPtrCastToGeneric);
3074 // Casting from Generic to an eligible pointer.
3075 if (SrcSC == SPIRV::StorageClass::Generic && isGenericCastablePtr(SC: DstSC))
3076 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpGenericCastToPtr);
3077 // Casting between 2 eligible pointers using Generic as an intermediary.
3078 if (isGenericCastablePtr(SC: SrcSC) && isGenericCastablePtr(SC: DstSC)) {
3079 SPIRVTypeInst GenericPtrTy =
3080 GR.changePointerStorageClass(PtrType: SrcPtrTy, SC: SPIRV::StorageClass::Generic, I);
3081 Register Tmp = createVirtualRegister(SpvType: GenericPtrTy, GR: &GR, MRI, MF: MRI->getMF());
3082 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpPtrCastToGeneric))
3083 .addDef(RegNo: Tmp)
3084 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: GenericPtrTy))
3085 .addUse(RegNo: SrcPtr)
3086 .constrainAllUses(TII, TRI, RBI);
3087 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpGenericCastToPtr))
3088 .addDef(RegNo: ResVReg)
3089 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3090 .addUse(RegNo: Tmp)
3091 .constrainAllUses(TII, TRI, RBI);
3092 return true;
3093 }
3094
3095 // Check if instructions from the SPV_INTEL_usm_storage_classes extension may
3096 // be applied
3097 if (isUSMStorageClass(SC: SrcSC) && DstSC == SPIRV::StorageClass::CrossWorkgroup)
3098 return selectUnOp(ResVReg, ResType, I,
3099 Opcode: SPIRV::OpPtrCastToCrossWorkgroupINTEL);
3100 if (SrcSC == SPIRV::StorageClass::CrossWorkgroup && isUSMStorageClass(SC: DstSC))
3101 return selectUnOp(ResVReg, ResType, I,
3102 Opcode: SPIRV::OpCrossWorkgroupCastToPtrINTEL);
3103 if (isUSMStorageClass(SC: SrcSC) && DstSC == SPIRV::StorageClass::Generic)
3104 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpPtrCastToGeneric);
3105 if (SrcSC == SPIRV::StorageClass::Generic && isUSMStorageClass(SC: DstSC))
3106 return selectUnOp(ResVReg, ResType, I, Opcode: SPIRV::OpGenericCastToPtr);
3107
3108 // Bitcast for pointers requires that the address spaces must match
3109 return false;
3110}
3111
3112// G_PTRMASK - Apply a bitmask to a pointer value.
3113// Result = Ptr & Mask
3114// We need to convert the pointer to an integer, perform the AND operation,
3115// and convert back to a pointer.
3116bool SPIRVInstructionSelector::selectPtrMask(Register ResVReg,
3117 SPIRVTypeInst ResType,
3118 MachineInstr &I) const {
3119 if (STI.isLogicalSPIRV())
3120 return diagnoseUnsupported(
3121 I, Msg: "G_PTRMASK is not supported with logical SPIR-V");
3122 MachineBasicBlock &BB = *I.getParent();
3123 MachineFunction &MF = *BB.getParent();
3124 const DebugLoc &DL = I.getDebugLoc();
3125
3126 Register PtrReg = I.getOperand(i: 1).getReg();
3127 Register MaskReg = I.getOperand(i: 2).getReg();
3128
3129 SPIRVTypeInst MaskType = GR.getSPIRVTypeForVReg(VReg: MaskReg);
3130
3131 // Convert pointer to integer.
3132 Register PtrAsInt = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: MaskType));
3133 GR.assignSPIRVTypeToVReg(Type: MaskType, VReg: PtrAsInt, MF);
3134
3135 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpConvertPtrToU))
3136 .addDef(RegNo: PtrAsInt)
3137 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: MaskType))
3138 .addUse(RegNo: PtrReg)
3139 .constrainAllUses(TII, TRI, RBI);
3140
3141 // Perform bitwise AND.
3142 Register MaskedInt = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: MaskType));
3143 GR.assignSPIRVTypeToVReg(Type: MaskType, VReg: MaskedInt, MF);
3144
3145 unsigned AndOpcode = GR.getScalarOrVectorComponentCount(Type: MaskType) > 1
3146 ? SPIRV::OpBitwiseAndV
3147 : SPIRV::OpBitwiseAndS;
3148
3149 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: AndOpcode))
3150 .addDef(RegNo: MaskedInt)
3151 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: MaskType))
3152 .addUse(RegNo: PtrAsInt)
3153 .addUse(RegNo: MaskReg)
3154 .constrainAllUses(TII, TRI, RBI);
3155
3156 // Convert integer back to pointer.
3157 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpConvertUToPtr))
3158 .addDef(RegNo: ResVReg)
3159 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3160 .addUse(RegNo: MaskedInt)
3161 .constrainAllUses(TII, TRI, RBI);
3162
3163 return true;
3164}
3165
3166static unsigned getFCmpOpcode(unsigned PredNum) {
3167 auto Pred = static_cast<CmpInst::Predicate>(PredNum);
3168 switch (Pred) {
3169 case CmpInst::FCMP_OEQ:
3170 return SPIRV::OpFOrdEqual;
3171 case CmpInst::FCMP_OGE:
3172 return SPIRV::OpFOrdGreaterThanEqual;
3173 case CmpInst::FCMP_OGT:
3174 return SPIRV::OpFOrdGreaterThan;
3175 case CmpInst::FCMP_OLE:
3176 return SPIRV::OpFOrdLessThanEqual;
3177 case CmpInst::FCMP_OLT:
3178 return SPIRV::OpFOrdLessThan;
3179 case CmpInst::FCMP_ONE:
3180 return SPIRV::OpFOrdNotEqual;
3181 case CmpInst::FCMP_ORD:
3182 return SPIRV::OpOrdered;
3183 case CmpInst::FCMP_UEQ:
3184 return SPIRV::OpFUnordEqual;
3185 case CmpInst::FCMP_UGE:
3186 return SPIRV::OpFUnordGreaterThanEqual;
3187 case CmpInst::FCMP_UGT:
3188 return SPIRV::OpFUnordGreaterThan;
3189 case CmpInst::FCMP_ULE:
3190 return SPIRV::OpFUnordLessThanEqual;
3191 case CmpInst::FCMP_ULT:
3192 return SPIRV::OpFUnordLessThan;
3193 case CmpInst::FCMP_UNE:
3194 return SPIRV::OpFUnordNotEqual;
3195 case CmpInst::FCMP_UNO:
3196 return SPIRV::OpUnordered;
3197 default:
3198 llvm_unreachable("Unknown predicate type for FCmp");
3199 }
3200}
3201
3202static unsigned getICmpOpcode(unsigned PredNum) {
3203 auto Pred = static_cast<CmpInst::Predicate>(PredNum);
3204 switch (Pred) {
3205 case CmpInst::ICMP_EQ:
3206 return SPIRV::OpIEqual;
3207 case CmpInst::ICMP_NE:
3208 return SPIRV::OpINotEqual;
3209 case CmpInst::ICMP_SGE:
3210 return SPIRV::OpSGreaterThanEqual;
3211 case CmpInst::ICMP_SGT:
3212 return SPIRV::OpSGreaterThan;
3213 case CmpInst::ICMP_SLE:
3214 return SPIRV::OpSLessThanEqual;
3215 case CmpInst::ICMP_SLT:
3216 return SPIRV::OpSLessThan;
3217 case CmpInst::ICMP_UGE:
3218 return SPIRV::OpUGreaterThanEqual;
3219 case CmpInst::ICMP_UGT:
3220 return SPIRV::OpUGreaterThan;
3221 case CmpInst::ICMP_ULE:
3222 return SPIRV::OpULessThanEqual;
3223 case CmpInst::ICMP_ULT:
3224 return SPIRV::OpULessThan;
3225 default:
3226 llvm_unreachable("Unknown predicate type for ICmp");
3227 }
3228}
3229
3230static unsigned getPtrCmpOpcode(unsigned Pred) {
3231 switch (static_cast<CmpInst::Predicate>(Pred)) {
3232 case CmpInst::ICMP_EQ:
3233 return SPIRV::OpPtrEqual;
3234 case CmpInst::ICMP_NE:
3235 return SPIRV::OpPtrNotEqual;
3236 default:
3237 llvm_unreachable("Unknown predicate type for pointer comparison");
3238 }
3239}
3240
3241// Return the logical operation, or abort if none exists.
3242static unsigned getBoolCmpOpcode(unsigned PredNum) {
3243 auto Pred = static_cast<CmpInst::Predicate>(PredNum);
3244 switch (Pred) {
3245 case CmpInst::ICMP_EQ:
3246 return SPIRV::OpLogicalEqual;
3247 case CmpInst::ICMP_NE:
3248 return SPIRV::OpLogicalNotEqual;
3249 default:
3250 llvm_unreachable("Unknown predicate type for Bool comparison");
3251 }
3252}
3253
3254static APFloat getZeroFP(const Type *LLVMFloatTy) {
3255 if (!LLVMFloatTy)
3256 return APFloat::getZero(Sem: APFloat::IEEEsingle());
3257 switch (LLVMFloatTy->getScalarType()->getTypeID()) {
3258 case Type::HalfTyID:
3259 return APFloat::getZero(Sem: APFloat::IEEEhalf());
3260 case Type::BFloatTyID:
3261 return APFloat::getZero(Sem: APFloat::BFloat());
3262 default:
3263 case Type::FloatTyID:
3264 return APFloat::getZero(Sem: APFloat::IEEEsingle());
3265 case Type::DoubleTyID:
3266 return APFloat::getZero(Sem: APFloat::IEEEdouble());
3267 }
3268}
3269
3270static APFloat getOneFP(const Type *LLVMFloatTy) {
3271 if (!LLVMFloatTy)
3272 return APFloat::getOne(Sem: APFloat::IEEEsingle());
3273 switch (LLVMFloatTy->getScalarType()->getTypeID()) {
3274 case Type::HalfTyID:
3275 return APFloat::getOne(Sem: APFloat::IEEEhalf());
3276 case Type::BFloatTyID:
3277 return APFloat::getOne(Sem: APFloat::BFloat());
3278 default:
3279 case Type::FloatTyID:
3280 return APFloat::getOne(Sem: APFloat::IEEEsingle());
3281 case Type::DoubleTyID:
3282 return APFloat::getOne(Sem: APFloat::IEEEdouble());
3283 }
3284}
3285
3286bool SPIRVInstructionSelector::selectAnyOrAll(Register ResVReg,
3287 SPIRVTypeInst ResType,
3288 MachineInstr &I,
3289 unsigned OpAnyOrAll) const {
3290 assert(I.getNumOperands() == 3);
3291 assert(I.getOperand(2).isReg());
3292 MachineBasicBlock &BB = *I.getParent();
3293 Register InputRegister = I.getOperand(i: 2).getReg();
3294 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputRegister);
3295
3296 assert(InputType && "VReg has no type assigned");
3297
3298 bool IsBoolTy = GR.isScalarOrVectorOfType(VReg: InputRegister, TypeOpcode: SPIRV::OpTypeBool);
3299 if (IsBoolTy && !isVectorType(SPVTy: InputType)) {
3300 assert(ResVReg == I.getOperand(0).getReg());
3301 return BuildCOPY(DestReg: ResVReg, SrcReg: InputRegister, I);
3302 }
3303
3304 bool IsFloatTy = GR.isScalarOrVectorOfType(VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3305 unsigned SpirvNotEqualId =
3306 IsFloatTy ? SPIRV::OpFOrdNotEqual : SPIRV::OpINotEqual;
3307 SPIRVTypeInst SpvBoolScalarTy = GR.getOrCreateSPIRVBoolType(I, TII);
3308 SPIRVTypeInst SpvBoolTy = SpvBoolScalarTy;
3309 Register NotEqualReg = ResVReg;
3310
3311 if (isVectorType(SPVTy: InputType)) {
3312 NotEqualReg =
3313 IsBoolTy ? InputRegister
3314 : createVirtualRegister(SpvType: SpvBoolTy, GR: &GR, MRI, MF: MRI->getMF());
3315 const unsigned NumElts = GR.getScalarOrVectorComponentCount(Type: InputType);
3316 SpvBoolTy = GR.getOrCreateSPIRVVectorType(BaseType: SpvBoolTy, NumElements: NumElts, I, TII);
3317 }
3318
3319 if (!IsBoolTy) {
3320 Register ConstZeroReg =
3321 IsFloatTy ? buildZerosValF(ResType: InputType, I) : buildZerosVal(ResType: InputType, I);
3322
3323 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SpirvNotEqualId))
3324 .addDef(RegNo: NotEqualReg)
3325 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SpvBoolTy))
3326 .addUse(RegNo: InputRegister)
3327 .addUse(RegNo: ConstZeroReg)
3328 .constrainAllUses(TII, TRI, RBI);
3329 }
3330
3331 if (isVectorType(SPVTy: InputType))
3332 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: OpAnyOrAll))
3333 .addDef(RegNo: ResVReg)
3334 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SpvBoolScalarTy))
3335 .addUse(RegNo: NotEqualReg)
3336 .constrainAllUses(TII, TRI, RBI);
3337 return true;
3338}
3339
3340bool SPIRVInstructionSelector::selectAll(Register ResVReg,
3341 SPIRVTypeInst ResType,
3342 MachineInstr &I) const {
3343 return selectAnyOrAll(ResVReg, ResType, I, OpAnyOrAll: SPIRV::OpAll);
3344}
3345
3346bool SPIRVInstructionSelector::selectAny(Register ResVReg,
3347 SPIRVTypeInst ResType,
3348 MachineInstr &I) const {
3349 return selectAnyOrAll(ResVReg, ResType, I, OpAnyOrAll: SPIRV::OpAny);
3350}
3351
3352// Select the OpDot instruction for the given float dot
3353bool SPIRVInstructionSelector::selectFloatDot(Register ResVReg,
3354 SPIRVTypeInst ResType,
3355 MachineInstr &I) const {
3356 assert(I.getNumOperands() == 4);
3357 assert(I.getOperand(2).isReg());
3358 assert(I.getOperand(3).isReg());
3359
3360 [[maybe_unused]] SPIRVTypeInst VecType =
3361 GR.getSPIRVTypeForVReg(VReg: I.getOperand(i: 2).getReg());
3362
3363 assert(((VecType->getOpcode() == SPIRV::OpTypeVector &&
3364 GR.getScalarOrVectorComponentCount(VecType) > 1) ||
3365 VecType->getOpcode() == SPIRV::OpTypeVectorIdEXT) &&
3366 "dot product requires either a vector of at least 2 components or"
3367 " the SPV_EXT_long vector extension.");
3368
3369 [[maybe_unused]] SPIRVTypeInst EltType =
3370 GR.getScalarOrVectorComponentType(Type: VecType);
3371
3372 assert(EltType->getOpcode() == SPIRV::OpTypeFloat);
3373
3374 MachineBasicBlock &BB = *I.getParent();
3375 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpDot))
3376 .addDef(RegNo: ResVReg)
3377 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3378 .addUse(RegNo: I.getOperand(i: 2).getReg())
3379 .addUse(RegNo: I.getOperand(i: 3).getReg())
3380 .constrainAllUses(TII, TRI, RBI);
3381 return true;
3382}
3383
3384bool SPIRVInstructionSelector::selectIntegerDot(Register ResVReg,
3385 SPIRVTypeInst ResType,
3386 MachineInstr &I,
3387 bool Signed) const {
3388 assert(I.getNumOperands() == 4);
3389 assert(I.getOperand(2).isReg());
3390 assert(I.getOperand(3).isReg());
3391 MachineBasicBlock &BB = *I.getParent();
3392
3393 auto DotOp = Signed ? SPIRV::OpSDot : SPIRV::OpUDot;
3394 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: DotOp))
3395 .addDef(RegNo: ResVReg)
3396 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3397 .addUse(RegNo: I.getOperand(i: 2).getReg())
3398 .addUse(RegNo: I.getOperand(i: 3).getReg())
3399 .constrainAllUses(TII, TRI, RBI);
3400 return true;
3401}
3402
3403// Since pre-1.6 SPIRV has no integer dot implementation,
3404// expand by piecewise multiplying and adding the results
3405bool SPIRVInstructionSelector::selectIntegerDotExpansion(
3406 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
3407 assert(I.getNumOperands() == 4);
3408 assert(I.getOperand(2).isReg());
3409 assert(I.getOperand(3).isReg());
3410 MachineBasicBlock &BB = *I.getParent();
3411
3412 // Multiply the vectors, then sum the results
3413 Register Vec0 = I.getOperand(i: 2).getReg();
3414 Register Vec1 = I.getOperand(i: 3).getReg();
3415 Register TmpVec = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
3416 SPIRVTypeInst VecType = GR.getSPIRVTypeForVReg(VReg: Vec0);
3417
3418 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIMulV))
3419 .addDef(RegNo: TmpVec)
3420 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: VecType))
3421 .addUse(RegNo: Vec0)
3422 .addUse(RegNo: Vec1)
3423 .constrainAllUses(TII, TRI, RBI);
3424
3425 assert(((VecType->getOpcode() == SPIRV::OpTypeVector &&
3426 GR.getScalarOrVectorComponentCount(VecType) > 1) ||
3427 VecType->getOpcode() == SPIRV::OpTypeVectorIdEXT) &&
3428 "dot product requires either a vector of at least 2 components "
3429 "or the SPV_EXT_long_vector extension.");
3430
3431 Register Res = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
3432 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
3433 .addDef(RegNo: Res)
3434 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3435 .addUse(RegNo: TmpVec)
3436 .addImm(Val: 0)
3437 .constrainAllUses(TII, TRI, RBI);
3438
3439 for (unsigned i = 1; i < GR.getScalarOrVectorComponentCount(Type: VecType); i++) {
3440 Register Elt = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
3441
3442 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
3443 .addDef(RegNo: Elt)
3444 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3445 .addUse(RegNo: TmpVec)
3446 .addImm(Val: i)
3447 .constrainAllUses(TII, TRI, RBI);
3448
3449 Register Sum = i < GR.getScalarOrVectorComponentCount(Type: VecType) - 1
3450 ? MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType))
3451 : ResVReg;
3452
3453 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIAddS))
3454 .addDef(RegNo: Sum)
3455 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3456 .addUse(RegNo: Res)
3457 .addUse(RegNo: Elt)
3458 .constrainAllUses(TII, TRI, RBI);
3459 Res = Sum;
3460 }
3461
3462 return true;
3463}
3464
3465bool SPIRVInstructionSelector::selectOpIsInf(Register ResVReg,
3466 SPIRVTypeInst ResType,
3467 MachineInstr &I) const {
3468 MachineBasicBlock &BB = *I.getParent();
3469 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIsInf))
3470 .addDef(RegNo: ResVReg)
3471 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3472 .addUse(RegNo: I.getOperand(i: 2).getReg())
3473 .constrainAllUses(TII, TRI, RBI);
3474 return true;
3475}
3476
3477bool SPIRVInstructionSelector::selectOpIsNan(Register ResVReg,
3478 SPIRVTypeInst ResType,
3479 MachineInstr &I) const {
3480 MachineBasicBlock &BB = *I.getParent();
3481 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIsNan))
3482 .addDef(RegNo: ResVReg)
3483 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3484 .addUse(RegNo: I.getOperand(i: 2).getReg())
3485 .constrainAllUses(TII, TRI, RBI);
3486 return true;
3487}
3488
3489bool SPIRVInstructionSelector::selectOpIsFinite(Register ResVReg,
3490 SPIRVTypeInst ResType,
3491 MachineInstr &I) const {
3492 // OpIsFinite requires Kernel capability; emulate with OpIsInf & OpIsNan
3493 MachineBasicBlock &BB = *I.getParent();
3494 Register Src = I.getOperand(i: 2).getReg();
3495 Register TypeID = GR.getSPIRVTypeID(SpirvType: ResType);
3496 const DebugLoc &DL = I.getDebugLoc();
3497
3498 if (!STI.isShader()) {
3499 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpIsFinite))
3500 .addDef(RegNo: ResVReg)
3501 .addUse(RegNo: TypeID)
3502 .addUse(RegNo: Src)
3503 .constrainAllUses(TII, TRI, RBI);
3504 return true;
3505 }
3506
3507 Register IsInfReg = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3508 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpIsInf))
3509 .addDef(RegNo: IsInfReg)
3510 .addUse(RegNo: TypeID)
3511 .addUse(RegNo: Src)
3512 .constrainAllUses(TII, TRI, RBI);
3513
3514 Register IsNanReg = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3515 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpIsNan))
3516 .addDef(RegNo: IsNanReg)
3517 .addUse(RegNo: TypeID)
3518 .addUse(RegNo: Src)
3519 .constrainAllUses(TII, TRI, RBI);
3520
3521 Register OrReg = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3522 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpLogicalOr))
3523 .addDef(RegNo: OrReg)
3524 .addUse(RegNo: TypeID)
3525 .addUse(RegNo: IsInfReg)
3526 .addUse(RegNo: IsNanReg)
3527 .constrainAllUses(TII, TRI, RBI);
3528
3529 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpLogicalNot))
3530 .addDef(RegNo: ResVReg)
3531 .addUse(RegNo: TypeID)
3532 .addUse(RegNo: OrReg)
3533 .constrainAllUses(TII, TRI, RBI);
3534 return true;
3535}
3536
3537bool SPIRVInstructionSelector::selectOpIsNormal(Register ResVReg,
3538 SPIRVTypeInst ResType,
3539 MachineInstr &I) const {
3540 MachineBasicBlock &BB = *I.getParent();
3541 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIsNormal))
3542 .addDef(RegNo: ResVReg)
3543 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3544 .addUse(RegNo: I.getOperand(i: 2).getReg())
3545 .constrainAllUses(TII, TRI, RBI);
3546 return true;
3547}
3548
3549template <bool Signed>
3550bool SPIRVInstructionSelector::selectDot4AddPacked(Register ResVReg,
3551 SPIRVTypeInst ResType,
3552 MachineInstr &I) const {
3553 assert(I.getNumOperands() == 5);
3554 assert(I.getOperand(2).isReg());
3555 assert(I.getOperand(3).isReg());
3556 assert(I.getOperand(4).isReg());
3557 MachineBasicBlock &BB = *I.getParent();
3558
3559 Register Acc = I.getOperand(i: 2).getReg();
3560 Register X = I.getOperand(i: 3).getReg();
3561 Register Y = I.getOperand(i: 4).getReg();
3562
3563 auto DotOp = Signed ? SPIRV::OpSDot : SPIRV::OpUDot;
3564 Register Dot = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
3565 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: DotOp))
3566 .addDef(RegNo: Dot)
3567 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3568 .addUse(RegNo: X)
3569 .addUse(RegNo: Y);
3570 MIB.addImm(Val: SPIRV::BuiltIn::PackedVectorFormat4x8Bit);
3571 MIB.constrainAllUses(TII, TRI, RBI);
3572
3573 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIAddS))
3574 .addDef(RegNo: ResVReg)
3575 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3576 .addUse(RegNo: Dot)
3577 .addUse(RegNo: Acc)
3578 .constrainAllUses(TII, TRI, RBI);
3579 return true;
3580}
3581
3582// Since pre-1.6 SPIRV has no DotProductInput4x8BitPacked implementation,
3583// extract the elements of the packed inputs, multiply them and add the result
3584// to the accumulator.
3585template <bool Signed>
3586bool SPIRVInstructionSelector::selectDot4AddPackedExpansion(
3587 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
3588 assert(I.getNumOperands() == 5);
3589 assert(I.getOperand(2).isReg());
3590 assert(I.getOperand(3).isReg());
3591 assert(I.getOperand(4).isReg());
3592 MachineBasicBlock &BB = *I.getParent();
3593
3594 Register Acc = I.getOperand(i: 2).getReg();
3595 Register X = I.getOperand(i: 3).getReg();
3596 Register Y = I.getOperand(i: 4).getReg();
3597
3598 SPIRVTypeInst EltType = GR.getOrCreateSPIRVIntegerType(BitWidth: 8, I, TII);
3599 auto ExtractOp =
3600 Signed ? SPIRV::OpBitFieldSExtract : SPIRV::OpBitFieldUExtract;
3601
3602 bool ZeroAsNull = !STI.isShader();
3603 // Extract the i8 element, multiply and add it to the accumulator
3604 for (unsigned i = 0; i < 4; i++) {
3605 // A[i]
3606 Register AElt = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3607 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: ExtractOp))
3608 .addDef(RegNo: AElt)
3609 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3610 .addUse(RegNo: X)
3611 .addUse(RegNo: GR.getOrCreateConstInt(Val: i * 8, I, SpvType: EltType, TII, ZeroAsNull))
3612 .addUse(RegNo: GR.getOrCreateConstInt(Val: 8, I, SpvType: EltType, TII, ZeroAsNull))
3613 .constrainAllUses(TII, TRI, RBI);
3614
3615 // B[i]
3616 Register BElt = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3617 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: ExtractOp))
3618 .addDef(RegNo: BElt)
3619 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3620 .addUse(RegNo: Y)
3621 .addUse(RegNo: GR.getOrCreateConstInt(Val: i * 8, I, SpvType: EltType, TII, ZeroAsNull))
3622 .addUse(RegNo: GR.getOrCreateConstInt(Val: 8, I, SpvType: EltType, TII, ZeroAsNull))
3623 .constrainAllUses(TII, TRI, RBI);
3624
3625 // A[i] * B[i]
3626 Register Mul = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3627 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIMulS))
3628 .addDef(RegNo: Mul)
3629 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3630 .addUse(RegNo: AElt)
3631 .addUse(RegNo: BElt)
3632 .constrainAllUses(TII, TRI, RBI);
3633
3634 // Discard 24 highest-bits so that stored i32 register is i8 equivalent
3635 Register MaskMul = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3636 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: ExtractOp))
3637 .addDef(RegNo: MaskMul)
3638 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3639 .addUse(RegNo: Mul)
3640 .addUse(RegNo: GR.getOrCreateConstInt(Val: 0, I, SpvType: EltType, TII, ZeroAsNull))
3641 .addUse(RegNo: GR.getOrCreateConstInt(Val: 8, I, SpvType: EltType, TII, ZeroAsNull))
3642 .constrainAllUses(TII, TRI, RBI);
3643
3644 // Acc = Acc + A[i] * B[i]
3645 Register Sum =
3646 i < 3 ? MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass) : ResVReg;
3647 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIAddS))
3648 .addDef(RegNo: Sum)
3649 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3650 .addUse(RegNo: Acc)
3651 .addUse(RegNo: MaskMul)
3652 .constrainAllUses(TII, TRI, RBI);
3653
3654 Acc = Sum;
3655 }
3656
3657 return true;
3658}
3659
3660/// Transform saturate(x) to clamp(x, 0.0f, 1.0f) as SPIRV
3661/// does not have a saturate builtin.
3662bool SPIRVInstructionSelector::selectSaturate(Register ResVReg,
3663 SPIRVTypeInst ResType,
3664 MachineInstr &I) const {
3665 assert(I.getNumOperands() == 3);
3666 assert(I.getOperand(2).isReg());
3667 MachineBasicBlock &BB = *I.getParent();
3668 Register VZero = buildZerosValF(ResType, I);
3669 Register VOne = buildOnesValF(ResType, I);
3670
3671 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
3672 .addDef(RegNo: ResVReg)
3673 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3674 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
3675 .addImm(Val: GL::FClamp)
3676 .addUse(RegNo: I.getOperand(i: 2).getReg())
3677 .addUse(RegNo: VZero)
3678 .addUse(RegNo: VOne)
3679 .constrainAllUses(TII, TRI, RBI);
3680 return true;
3681}
3682
3683bool SPIRVInstructionSelector::selectSign(Register ResVReg,
3684 SPIRVTypeInst ResType,
3685 MachineInstr &I) const {
3686 assert(I.getNumOperands() == 3);
3687 assert(I.getOperand(2).isReg());
3688 MachineBasicBlock &BB = *I.getParent();
3689 Register InputRegister = I.getOperand(i: 2).getReg();
3690 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputRegister);
3691 auto &DL = I.getDebugLoc();
3692
3693 if (!InputType)
3694 return diagnoseUnsupported(I, Msg: "Input Type could not be determined.");
3695
3696 bool IsFloatTy = GR.isScalarOrVectorOfType(VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3697
3698 unsigned SignBitWidth = GR.getScalarOrVectorBitWidth(Type: InputType);
3699 unsigned ResBitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
3700
3701 bool NeedsConversion = IsFloatTy || SignBitWidth != ResBitWidth;
3702
3703 auto SignOpcode = IsFloatTy ? GL::FSign : GL::SSign;
3704 Register SignReg = NeedsConversion
3705 ? MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass)
3706 : ResVReg;
3707
3708 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpExtInst))
3709 .addDef(RegNo: SignReg)
3710 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: InputType))
3711 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
3712 .addImm(Val: SignOpcode)
3713 .addUse(RegNo: InputRegister)
3714 .constrainAllUses(TII, TRI, RBI);
3715
3716 if (NeedsConversion) {
3717 auto ConvertOpcode = IsFloatTy ? SPIRV::OpConvertFToS : SPIRV::OpSConvert;
3718 BuildMI(BB&: *I.getParent(), I, MIMD: DL, MCID: TII.get(Opcode: ConvertOpcode))
3719 .addDef(RegNo: ResVReg)
3720 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3721 .addUse(RegNo: SignReg)
3722 .constrainAllUses(TII, TRI, RBI);
3723 }
3724
3725 return true;
3726}
3727
3728bool SPIRVInstructionSelector::selectWaveOpInst(Register ResVReg,
3729 SPIRVTypeInst ResType,
3730 MachineInstr &I,
3731 unsigned Opcode) const {
3732 MachineBasicBlock &BB = *I.getParent();
3733 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
3734
3735 auto BMI = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
3736 .addDef(RegNo: ResVReg)
3737 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3738 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I,
3739 SpvType: IntTy, TII, ZeroAsNull: !STI.isShader()));
3740
3741 for (unsigned J = 2; J < I.getNumOperands(); J++) {
3742 BMI.addUse(RegNo: I.getOperand(i: J).getReg());
3743 }
3744
3745 BMI.constrainAllUses(TII, TRI, RBI);
3746 return true;
3747}
3748
3749bool SPIRVInstructionSelector::selectBarrierInst(MachineInstr &I,
3750 unsigned Scope,
3751 unsigned MemSem,
3752 bool WithGroupSync) const {
3753 auto BarrierType =
3754 WithGroupSync ? SPIRV::OpControlBarrier : SPIRV::OpMemoryBarrier;
3755
3756 MemSem |= SPIRV::MemorySemantics::AcquireRelease;
3757
3758 assert(((Scope != SPIRV::Scope::Workgroup) ||
3759 ((MemSem & SPIRV::MemorySemantics::WorkgroupMemory) > 0)) &&
3760 "Workgroup Scope must set WorkGroupMemory semantic "
3761 "in Barrier instruction");
3762
3763 assert(((Scope != SPIRV::Scope::Device) ||
3764 ((MemSem & SPIRV::MemorySemantics::UniformMemory) > 0 &&
3765 (MemSem & SPIRV::MemorySemantics::ImageMemory) > 0)) &&
3766 "Device Scope must set UniformMemory and ImageMemory semantic "
3767 "in Barrier instruction");
3768
3769 MachineBasicBlock &BB = *I.getParent();
3770 auto MI = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: BarrierType));
3771
3772 // OpControlBarrier needs to also set Execution Scope
3773 if (WithGroupSync) {
3774 Register ExecReg = buildI32ConstantInEntryBlock(Val: SPIRV::Scope::Workgroup, I);
3775 MI.addUse(RegNo: ExecReg);
3776 }
3777
3778 Register ScopeReg = buildI32ConstantInEntryBlock(Val: Scope, I);
3779 Register MemSemReg = buildI32ConstantInEntryBlock(Val: MemSem, I);
3780
3781 MI.addUse(RegNo: ScopeReg).addUse(RegNo: MemSemReg).constrainAllUses(TII, TRI, RBI);
3782 return true;
3783}
3784
3785bool SPIRVInstructionSelector::selectWaveActiveCountBits(
3786 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
3787
3788 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
3789 SPIRVTypeInst BallotType = GR.getOrCreateSPIRVVectorType(BaseType: IntTy, NumElements: 4, I, TII);
3790 Register BallotReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: BallotType));
3791 if (!selectWaveOpInst(ResVReg: BallotReg, ResType: BallotType, I,
3792 Opcode: SPIRV::OpGroupNonUniformBallot))
3793 return false;
3794
3795 MachineBasicBlock &BB = *I.getParent();
3796 BuildMI(BB, I, MIMD: I.getDebugLoc(),
3797 MCID: TII.get(Opcode: SPIRV::OpGroupNonUniformBallotBitCount))
3798 .addDef(RegNo: ResVReg)
3799 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3800 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy, TII,
3801 ZeroAsNull: !STI.isShader()))
3802 .addImm(Val: SPIRV::GroupOperation::Reduce)
3803 .addUse(RegNo: BallotReg)
3804 .constrainAllUses(TII, TRI, RBI);
3805
3806 return true;
3807}
3808
3809bool SPIRVInstructionSelector::selectWaveActiveAllEqual(Register ResVReg,
3810 SPIRVTypeInst ResType,
3811 MachineInstr &I) const {
3812 MachineBasicBlock &BB = *I.getParent();
3813 const DebugLoc &DL = I.getDebugLoc();
3814
3815 // Input to the intrinsic
3816 Register InputReg = I.getOperand(i: 2).getReg();
3817 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputReg);
3818
3819 // Determine if input is vector
3820 unsigned NumElems = GR.getScalarOrVectorComponentCount(Type: InputType);
3821 bool IsVector = NumElems > 1 ||
3822 (InputType->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
3823 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector));
3824
3825 // Determine element types
3826 SPIRVTypeInst ElemInputType = GR.getScalarOrVectorComponentType(Type: InputType);
3827 SPIRVTypeInst ElemBoolType = GR.getScalarOrVectorComponentType(Type: ResType);
3828
3829 // Subgroup scope constant
3830 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
3831 Register ScopeConst = GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy,
3832 TII, ZeroAsNull: !STI.isShader());
3833
3834 // Scalar case
3835 if (!IsVector) {
3836 return selectWaveOpInst(ResVReg, ResType: ElemBoolType, I,
3837 Opcode: SPIRV::OpGroupNonUniformAllEqual);
3838 }
3839
3840 // Vector case
3841 SmallVector<Register, 4> ElementResults;
3842 ElementResults.reserve(N: NumElems);
3843
3844 for (unsigned Idx = 0; Idx < NumElems; ++Idx) {
3845 // Extract element
3846 Register ElemInput = InputReg;
3847 Register Extracted =
3848 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ElemInputType));
3849
3850 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
3851 .addDef(RegNo: Extracted)
3852 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ElemInputType))
3853 .addUse(RegNo: InputReg)
3854 .addImm(Val: Idx)
3855 .constrainAllUses(TII, TRI, RBI);
3856
3857 ElemInput = Extracted;
3858
3859 // Emit per-element AllEqual
3860 Register ElemResult =
3861 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ElemBoolType));
3862
3863 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpGroupNonUniformAllEqual))
3864 .addDef(RegNo: ElemResult)
3865 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ElemBoolType))
3866 .addUse(RegNo: ScopeConst)
3867 .addUse(RegNo: ElemInput)
3868 .constrainAllUses(TII, TRI, RBI);
3869
3870 ElementResults.push_back(Elt: ElemResult);
3871 }
3872
3873 // Reconstruct vector<bool>
3874 auto MIB = BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
3875 .addDef(RegNo: ResVReg)
3876 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
3877 for (Register R : ElementResults)
3878 MIB.addUse(RegNo: R);
3879
3880 MIB.constrainAllUses(TII, TRI, RBI);
3881
3882 return true;
3883}
3884
3885bool SPIRVInstructionSelector::selectWavePrefixBitCount(Register ResVReg,
3886 SPIRVTypeInst ResType,
3887 MachineInstr &I) const {
3888
3889 assert(I.getNumOperands() == 3);
3890
3891 auto Op = I.getOperand(i: 2);
3892 assert(Op.isReg());
3893
3894 MachineBasicBlock &BB = *I.getParent();
3895 DebugLoc DL = I.getDebugLoc();
3896
3897 Register InputRegister = Op.getReg();
3898 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputRegister);
3899
3900 if (!InputType)
3901 return diagnoseUnsupported(I, Msg: "Input Type could not be determined.");
3902
3903 if (InputType->getOpcode() != SPIRV::OpTypeBool)
3904 return diagnoseUnsupported(I, Msg: "WavePrefixBitCount requires boolean input");
3905
3906 // Types
3907 SPIRVTypeInst Int32Ty = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
3908
3909 // Ballot result type: vector<uint32>
3910 // Match DXC: %v4uint for Subgroup size
3911 SPIRVTypeInst BallotTy = GR.getOrCreateSPIRVVectorType(BaseType: Int32Ty, NumElements: 4, I, TII);
3912
3913 // Create a vreg for the ballot result
3914 Register BallotVReg = MRI->createVirtualRegister(RegClass: &SPIRV::IDRegClass);
3915
3916 // 1. OpGroupNonUniformBallot
3917 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpGroupNonUniformBallot))
3918 .addDef(RegNo: BallotVReg)
3919 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: BallotTy))
3920 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: Int32Ty, TII))
3921 .addUse(RegNo: InputRegister)
3922 .constrainAllUses(TII, TRI, RBI);
3923
3924 // 2. OpGroupNonUniformBallotBitCount
3925 BuildMI(BB, I, MIMD: DL, MCID: TII.get(Opcode: SPIRV::OpGroupNonUniformBallotBitCount))
3926 .addDef(RegNo: ResVReg)
3927 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
3928 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: Int32Ty, TII))
3929 .addImm(Val: SPIRV::GroupOperation::ExclusiveScan)
3930 .addUse(RegNo: BallotVReg)
3931 .constrainAllUses(TII, TRI, RBI);
3932
3933 return true;
3934}
3935
3936bool SPIRVInstructionSelector::selectWaveReduceMax(Register ResVReg,
3937 SPIRVTypeInst ResType,
3938 MachineInstr &I,
3939 bool IsUnsigned) const {
3940 return selectWaveReduce(
3941 ResVReg, ResType, I, IsUnsigned,
3942 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
3943 const bool IsFloatTy =
3944 GR.isScalarOrVectorOfType(VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3945 const auto IntOp = IsUnsigned ? SPIRV::OpGroupNonUniformUMax
3946 : SPIRV::OpGroupNonUniformSMax;
3947 return IsFloatTy ? SPIRV::OpGroupNonUniformFMax : IntOp;
3948 });
3949}
3950
3951bool SPIRVInstructionSelector::selectWaveReduceMin(Register ResVReg,
3952 SPIRVTypeInst ResType,
3953 MachineInstr &I,
3954 bool IsUnsigned) const {
3955 return selectWaveReduce(
3956 ResVReg, ResType, I, IsUnsigned,
3957 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
3958 const bool IsFloatTy =
3959 GR.isScalarOrVectorOfType(VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3960 const auto IntOp = IsUnsigned ? SPIRV::OpGroupNonUniformUMin
3961 : SPIRV::OpGroupNonUniformSMin;
3962 return IsFloatTy ? SPIRV::OpGroupNonUniformFMin : IntOp;
3963 });
3964}
3965
3966bool SPIRVInstructionSelector::selectWaveReduceSum(Register ResVReg,
3967 SPIRVTypeInst ResType,
3968 MachineInstr &I) const {
3969 return selectWaveReduce(ResVReg, ResType, I, /*IsUnsigned*/ false,
3970 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
3971 bool IsFloatTy = GR.isScalarOrVectorOfType(
3972 VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3973 return IsFloatTy ? SPIRV::OpGroupNonUniformFAdd
3974 : SPIRV::OpGroupNonUniformIAdd;
3975 });
3976}
3977
3978bool SPIRVInstructionSelector::selectWaveReduceProduct(Register ResVReg,
3979 SPIRVTypeInst ResType,
3980 MachineInstr &I) const {
3981 return selectWaveReduce(ResVReg, ResType, I, /*IsUnsigned*/ false,
3982 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
3983 bool IsFloatTy = GR.isScalarOrVectorOfType(
3984 VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
3985 return IsFloatTy ? SPIRV::OpGroupNonUniformFMul
3986 : SPIRV::OpGroupNonUniformIMul;
3987 });
3988}
3989
3990template <typename PickOpcodeFn>
3991bool SPIRVInstructionSelector::selectWaveReduce(
3992 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, bool IsUnsigned,
3993 PickOpcodeFn &&PickOpcode) const {
3994 assert(I.getNumOperands() == 3);
3995 assert(I.getOperand(2).isReg());
3996 MachineBasicBlock &BB = *I.getParent();
3997 Register InputRegister = I.getOperand(i: 2).getReg();
3998 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputRegister);
3999
4000 if (!InputType)
4001 return diagnoseUnsupported(I, Msg: "Input Type could not be determined.");
4002
4003 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4004 const unsigned Opcode = PickOpcode(InputRegister, IsUnsigned);
4005 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
4006 .addDef(RegNo: ResVReg)
4007 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4008 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy, TII,
4009 ZeroAsNull: !STI.isShader()))
4010 .addImm(Val: SPIRV::GroupOperation::Reduce)
4011 .addUse(RegNo: I.getOperand(i: 2).getReg())
4012 .constrainAllUses(TII, TRI, RBI);
4013 return true;
4014}
4015
4016bool SPIRVInstructionSelector::selectWaveReduceOp(Register ResVReg,
4017 SPIRVTypeInst ResType,
4018 MachineInstr &I,
4019 unsigned Opcode) const {
4020 return selectWaveReduce(
4021 ResVReg, ResType, I, IsUnsigned: false,
4022 PickOpcode: [&](Register InputRegister, bool IsUnsigned) { return Opcode; });
4023}
4024
4025bool SPIRVInstructionSelector::selectWaveExclusiveScanSum(
4026 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
4027 return selectWaveExclusiveScan(ResVReg, ResType, I, /*IsUnsigned*/ false,
4028 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
4029 bool IsFloatTy = GR.isScalarOrVectorOfType(
4030 VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
4031 return IsFloatTy
4032 ? SPIRV::OpGroupNonUniformFAdd
4033 : SPIRV::OpGroupNonUniformIAdd;
4034 });
4035}
4036
4037bool SPIRVInstructionSelector::selectWaveExclusiveScanProduct(
4038 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
4039 return selectWaveExclusiveScan(ResVReg, ResType, I, /*IsUnsigned*/ false,
4040 PickOpcode: [&](Register InputRegister, bool IsUnsigned) {
4041 bool IsFloatTy = GR.isScalarOrVectorOfType(
4042 VReg: InputRegister, TypeOpcode: SPIRV::OpTypeFloat);
4043 return IsFloatTy
4044 ? SPIRV::OpGroupNonUniformFMul
4045 : SPIRV::OpGroupNonUniformIMul;
4046 });
4047}
4048
4049template <typename PickOpcodeFn>
4050bool SPIRVInstructionSelector::selectWaveExclusiveScan(
4051 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, bool IsUnsigned,
4052 PickOpcodeFn &&PickOpcode) const {
4053 assert(I.getNumOperands() == 3);
4054 assert(I.getOperand(2).isReg());
4055 MachineBasicBlock &BB = *I.getParent();
4056 Register InputRegister = I.getOperand(i: 2).getReg();
4057 SPIRVTypeInst InputType = GR.getSPIRVTypeForVReg(VReg: InputRegister);
4058
4059 if (!InputType)
4060 return diagnoseUnsupported(I, Msg: "Input Type could not be determined.");
4061
4062 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4063 const unsigned Opcode = PickOpcode(InputRegister, IsUnsigned);
4064 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
4065 .addDef(RegNo: ResVReg)
4066 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4067 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy, TII,
4068 ZeroAsNull: !STI.isShader()))
4069 .addImm(Val: SPIRV::GroupOperation::ExclusiveScan)
4070 .addUse(RegNo: I.getOperand(i: 2).getReg())
4071 .constrainAllUses(TII, TRI, RBI);
4072 return true;
4073}
4074
4075bool SPIRVInstructionSelector::selectWaveMultiPrefixOp(
4076 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, unsigned Opcode,
4077 StringRef BuiltinName) const {
4078 if (!STI.canUseExtension(
4079 E: SPIRV::Extension::SPV_EXT_shader_subgroup_partitioned) &&
4080 !STI.canUseExtension(
4081 E: SPIRV::Extension::SPV_NV_shader_subgroup_partitioned))
4082 return diagnoseUnsupported(
4083 I, Msg: Twine(BuiltinName) +
4084 " requires SPV_EXT_shader_subgroup_partitioned or "
4085 "SPV_NV_shader_subgroup_partitioned");
4086
4087 assert(I.getNumOperands() == 7);
4088 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4089 SPIRVTypeInst MaskTy = GR.getOrCreateSPIRVVectorType(BaseType: IntTy, NumElements: 4, I, TII);
4090 Register Mask = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: MaskTy));
4091 GR.assignSPIRVTypeToVReg(Type: MaskTy, VReg: Mask, MF: MRI->getMF());
4092 auto MaskMIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4093 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
4094 .addDef(RegNo: Mask)
4095 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: MaskTy));
4096 for (unsigned Op = 3; Op != 7; ++Op)
4097 MaskMIB.addUse(RegNo: I.getOperand(i: Op).getReg());
4098 MaskMIB.constrainAllUses(TII, TRI, RBI);
4099
4100 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
4101 .addDef(RegNo: ResVReg)
4102 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4103 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy, TII,
4104 ZeroAsNull: !STI.isShader()))
4105 .addImm(Val: SPIRV::GroupOperation::PartitionedExclusiveScanNV)
4106 .addUse(RegNo: I.getOperand(i: 2).getReg())
4107 .addUse(RegNo: Mask)
4108 .constrainAllUses(TII, TRI, RBI);
4109 return true;
4110}
4111
4112bool SPIRVInstructionSelector::selectQuadSwap(Register ResVReg,
4113 SPIRVTypeInst ResType,
4114 MachineInstr &I,
4115 unsigned Direction) const {
4116 assert(I.getNumOperands() == 3);
4117 assert(I.getOperand(2).isReg());
4118 MachineBasicBlock &BB = *I.getParent();
4119 Register InputRegister = I.getOperand(i: 2).getReg();
4120
4121 SPIRVTypeInst IntTy = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4122 bool ZeroAsNull = !STI.isShader();
4123 Register DirectionReg =
4124 GR.getOrCreateConstInt(Val: Direction, I, SpvType: IntTy, TII, ZeroAsNull);
4125 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpGroupNonUniformQuadSwap))
4126 .addDef(RegNo: ResVReg)
4127 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4128 .addUse(RegNo: GR.getOrCreateConstInt(Val: SPIRV::Scope::Subgroup, I, SpvType: IntTy, TII,
4129 ZeroAsNull))
4130 .addUse(RegNo: InputRegister)
4131 .addUse(RegNo: DirectionReg)
4132 .constrainAllUses(TII, TRI, RBI);
4133 return true;
4134}
4135
4136bool SPIRVInstructionSelector::selectQuadAll(Register ResVReg,
4137 SPIRVTypeInst ResType,
4138 MachineInstr &I) const {
4139 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_quad_control))
4140 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {I.getOperand(i: 2).getReg()},
4141 Opcode: SPIRV::OpGroupNonUniformQuadAllKHR);
4142
4143 Register Result = I.getOperand(i: 2).getReg();
4144 for (unsigned Direction = 0; Direction != 3; ++Direction) {
4145 Register QuadValue = createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: MRI->getMF());
4146 Register Next =
4147 Direction == 2 ? ResVReg
4148 : createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: MRI->getMF());
4149 if (!selectQuadSwap(ResVReg: QuadValue, ResType, I, Direction) ||
4150 !selectOpWithSrcs(ResVReg: Next, ResType, I, Srcs: {Result, QuadValue},
4151 Opcode: SPIRV::OpLogicalAnd))
4152 return false;
4153 Result = Next;
4154 }
4155 return true;
4156}
4157
4158bool SPIRVInstructionSelector::selectBitreverseViaI32(Register ResVReg,
4159 SPIRVTypeInst ResType,
4160 MachineInstr &I,
4161 Register Op) const {
4162 SPIRVTypeInst Int32Type = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4163 const unsigned BitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
4164 Register ShiftConst =
4165 GR.getOrCreateConstInt(Val: 32 - BitWidth, I, SpvType: Int32Type, TII);
4166 unsigned ShiftOp = SPIRV::OpShiftRightLogicalS;
4167
4168 const unsigned N = GR.getScalarOrVectorComponentCount(Type: ResType);
4169 const unsigned ExtendOpcode = GR.isScalarOrVectorSigned(Type: ResType)
4170 ? SPIRV::OpSConvert
4171 : SPIRV::OpUConvert;
4172
4173 if (N > 1 || (ResType->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
4174 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector))) {
4175 Int32Type = GR.getOrCreateSPIRVVectorType(BaseType: Int32Type, NumElements: N, I, TII);
4176 ShiftOp = SPIRV::OpShiftRightLogicalV;
4177
4178 // Vector shifts require a composite constant
4179 const Register CompositeReg =
4180 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Int32Type));
4181 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4182 MCID: TII.get(Opcode: SPIRV::OpConstantComposite))
4183 .addDef(RegNo: CompositeReg)
4184 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: Int32Type));
4185 for (unsigned It = 0; It < N; ++It)
4186 MIB.addUse(RegNo: ShiftConst);
4187 MIB.constrainAllUses(TII, TRI, RBI);
4188
4189 ShiftConst = CompositeReg;
4190 }
4191
4192 // Converts the input to i32 (or vector of i32)
4193 Register ExtReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Int32Type));
4194 if (!selectOpWithSrcs(ResVReg: ExtReg, ResType: Int32Type, I, Srcs: {Op}, Opcode: ExtendOpcode))
4195 return false;
4196
4197 // Perform bitreverse on the i32 value
4198 Register BitrevReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Int32Type));
4199 if (!selectBitreverseNative(ResVReg: BitrevReg, ResType: Int32Type, I, Op: ExtReg))
4200 return false;
4201
4202 // Shift the bit-reversed value to get the final result.
4203 Register ShiftReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Int32Type));
4204 if (!selectOpWithSrcs(ResVReg: ShiftReg, ResType: Int32Type, I, Srcs: {BitrevReg, ShiftConst},
4205 Opcode: ShiftOp))
4206 return false;
4207
4208 // Finally, convert the result back.
4209 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {ShiftReg}, Opcode: ExtendOpcode);
4210}
4211
4212bool SPIRVInstructionSelector::handle64BitOverflow(
4213 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, Register SrcReg,
4214 unsigned int Opcode,
4215 std::function<bool(Register, SPIRVTypeInst, MachineInstr &, Register,
4216 unsigned)>
4217 CallbackFunction) const {
4218
4219 SPIRVTypeInst BaseType = GR.retrieveScalarOrVectorIntType(Type: ResType);
4220 assert(BaseType->getOpcode() == SPIRV::OpTypeInt &&
4221 "handle64BitOverflow should only be used for integer types");
4222 unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: ResType);
4223 assert(ComponentCount < 5 && "Vec 5+ will generate invalid SPIR-V ops");
4224
4225 MachineIRBuilder MIRBuilder(I);
4226 SPIRVTypeInst I64Type = GR.getOrCreateSPIRVIntegerType(BitWidth: 64, MIRBuilder);
4227 SPIRVTypeInst I64x2Type =
4228 GR.getOrCreateSPIRVVectorType(BaseType: I64Type, NumElements: 2, MIRBuilder, EmitIR: false);
4229 SPIRVTypeInst Vec2ResType =
4230 GR.getOrCreateSPIRVVectorType(BaseType, NumElements: 2, MIRBuilder, EmitIR: false);
4231
4232 std::vector<Register> PartialRegs;
4233
4234 unsigned CurrentComponent = 0;
4235 for (; CurrentComponent + 1 < ComponentCount; CurrentComponent += 2) {
4236 Register PopCountResult =
4237 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: I64x2Type));
4238
4239 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4240 MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
4241 .addDef(RegNo: PopCountResult)
4242 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: I64x2Type))
4243 .addUse(RegNo: SrcReg)
4244 .addUse(RegNo: SrcReg)
4245 .addImm(Val: CurrentComponent)
4246 .addImm(Val: CurrentComponent + 1);
4247
4248 MIB.constrainAllUses(TII, TRI, RBI);
4249
4250 Register SubVecReg =
4251 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Vec2ResType));
4252
4253 if (!CallbackFunction(SubVecReg, Vec2ResType, I, PopCountResult, Opcode))
4254 return false;
4255
4256 PartialRegs.push_back(x: SubVecReg);
4257 }
4258 // On odd component counts we need to handle one more component
4259 if (CurrentComponent != ComponentCount) {
4260 bool ZeroAsNull = !STI.isShader();
4261 Register FinalElemReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: I64Type));
4262 Register ConstIntLastIdx = GR.getOrCreateConstInt(
4263 Val: ComponentCount - 1, I, SpvType: BaseType, TII, ZeroAsNull);
4264
4265 if (!selectOpWithSrcs(ResVReg: FinalElemReg, ResType: I64Type, I, Srcs: {SrcReg, ConstIntLastIdx},
4266 Opcode: SPIRV::OpVectorExtractDynamic))
4267 return false;
4268
4269 Register FinalElemResReg =
4270 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: BaseType));
4271
4272 if (!CallbackFunction(FinalElemResReg, BaseType, I, FinalElemReg, Opcode))
4273 return false;
4274
4275 PartialRegs.push_back(x: FinalElemResReg);
4276 }
4277 // Join all the resulting registers back into the return type in order
4278 // (ie i32x2, i32x2, i32x1 -> i32x5)
4279 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: PartialRegs,
4280 Opcode: SPIRV::OpCompositeConstruct);
4281}
4282
4283bool SPIRVInstructionSelector::selectBitreverse64(Register ResVReg,
4284 SPIRVTypeInst ResType,
4285 MachineInstr &I,
4286 Register SrcReg) const {
4287 unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: ResType);
4288 if (ComponentCount > 2)
4289 return handle64BitOverflow(
4290 ResVReg, ResType, I, SrcReg, Opcode: SPIRV::OpBitReverse,
4291 CallbackFunction: [this](Register R, SPIRVTypeInst T, MachineInstr &I, Register S,
4292 unsigned O) { return this->selectBitreverse64(ResVReg: R, ResType: T, I, SrcReg: S); });
4293
4294 MachineIRBuilder MIRBuilder(I);
4295
4296 SPIRVTypeInst I32Type = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, MIRBuilder);
4297 SPIRVTypeInst VecI32Type = GR.getOrCreateSPIRVVectorType(
4298 BaseType: I32Type, NumElements: 2 * ComponentCount, MIRBuilder, /*IsSigned=*/EmitIR: false);
4299
4300 // Converts 64 bit into and array of 32 bit, containing 2 elements.
4301 Register Vec32 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: VecI32Type));
4302 if (!selectOpWithSrcs(ResVReg: Vec32, ResType: VecI32Type, I, Srcs: {SrcReg}, Opcode: SPIRV::OpBitcast))
4303 return false;
4304
4305 // Apply bitreverse on each 32 bit lane
4306 Register Reverse32 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: VecI32Type));
4307 if (!selectBitreverseNative(ResVReg: Reverse32, ResType: VecI32Type, I, Op: Vec32))
4308 return false;
4309
4310 // Reversing a 64-bit value = reverse each 32-bit half AND swap them,
4311 // so the old High word becomes lane 0 (low) and old Low becomes lane 1
4312 // (high).
4313 Register SwappedVec = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: VecI32Type));
4314 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4315 MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
4316 .addDef(RegNo: SwappedVec)
4317 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: VecI32Type))
4318 .addUse(RegNo: Reverse32)
4319 .addUse(RegNo: Reverse32);
4320 for (unsigned J = 0; J < ComponentCount; ++J) {
4321 MIB.addImm(Val: 2 * J + 1);
4322 MIB.addImm(Val: 2 * J);
4323 }
4324 MIB.constrainAllUses(TII, TRI, RBI);
4325
4326 // Groups 32 bit vector back to 64 bit scalar.
4327 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {SwappedVec}, Opcode: SPIRV::OpBitcast);
4328}
4329
4330bool SPIRVInstructionSelector::selectBitreverseNative(Register ResVReg,
4331 SPIRVTypeInst ResType,
4332 MachineInstr &I,
4333 Register Op) const {
4334 MachineBasicBlock &BB = *I.getParent();
4335 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBitReverse))
4336 .addDef(RegNo: ResVReg)
4337 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4338 .addUse(RegNo: Op)
4339 .constrainAllUses(TII, TRI, RBI);
4340 return true;
4341}
4342
4343bool SPIRVInstructionSelector::selectBitreverse(Register ResVReg,
4344 SPIRVTypeInst ResType,
4345 MachineInstr &I) const {
4346 Register OpReg = I.getOperand(i: 1).getReg();
4347
4348 // TODO: Fix shader behavior in case of VK_KHR_maintenance9 extension is set
4349 if (STI.isShader()) {
4350 SPIRVTypeInst OpType = GR.getSPIRVTypeForVReg(VReg: OpReg);
4351 switch (GR.getScalarOrVectorBitWidth(Type: OpType)) {
4352 case 8:
4353 case 16:
4354 case 24:
4355 return selectBitreverseViaI32(ResVReg, ResType, I, Op: OpReg);
4356 case 32:
4357 return selectBitreverseNative(ResVReg, ResType, I, Op: OpReg);
4358 case 64:
4359 return selectBitreverse64(ResVReg, ResType, I, SrcReg: OpReg);
4360 }
4361 return SPIRVInstructionSelector::diagnoseUnsupported(
4362 I, Msg: "G_BITREVERSE only support 16,32,64 bits.");
4363 }
4364
4365 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_bit_instructions))
4366 return selectBitreverseNative(ResVReg, ResType, I, Op: OpReg);
4367
4368 // Expansion bitreverse using bit manipulation operations
4369 // Algo: https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
4370 const unsigned BitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
4371 // TODO: add support for any bit width and bitwidth more than 64.
4372 if (BitWidth > 64 || !isPowerOf2_32(Value: BitWidth))
4373 return false;
4374
4375 const unsigned N = GR.getScalarOrVectorComponentCount(Type: ResType);
4376
4377 unsigned AndOp = SPIRV::OpBitwiseAndS;
4378 unsigned OrOp = SPIRV::OpBitwiseOrS;
4379 unsigned ShlOp = SPIRV::OpShiftLeftLogicalS;
4380 unsigned ShrOp = SPIRV::OpShiftRightLogicalS;
4381 if (N > 1 || (ResType->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
4382 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector))) {
4383 AndOp = SPIRV::OpBitwiseAndV;
4384 OrOp = SPIRV::OpBitwiseOrV;
4385 ShlOp = SPIRV::OpShiftLeftLogicalV;
4386 ShrOp = SPIRV::OpShiftRightLogicalV;
4387 }
4388
4389 // Helper, one swap per step: ((input>>shift)&mask)|((input&mask)<<shift),
4390 // RPN: input shift >> mask & input mask & shift << |
4391 auto SwapBits = [&](const Register Input, const uint64_t Mask,
4392 const unsigned Shift) -> Register {
4393 auto CreateConst = [&](const uint64_t Value) -> Register {
4394 if (N == 1 &&
4395 (ResType->getOpcode() != SPIRV::OpTypeVectorIdEXT ||
4396 !STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector)))
4397 return GR.getOrCreateConstInt(
4398 Val: Value, I, SpvType: GR.retrieveScalarOrVectorIntType(Type: ResType), TII);
4399 return GR.getOrCreateConstVector(Val: Value, I, SpvType: ResType, TII);
4400 };
4401
4402 Register MaskReg = CreateConst(Mask);
4403 Register ShiftReg = CreateConst(Shift);
4404 Register T1 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4405 Register T2 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4406 Register T3 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4407 Register T4 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4408 Register Result = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4409
4410 if (!selectOpWithSrcs(ResVReg: T1, ResType, I, Srcs: {Input, ShiftReg}, Opcode: ShrOp) ||
4411 !selectOpWithSrcs(ResVReg: T2, ResType, I, Srcs: {T1, MaskReg}, Opcode: AndOp) ||
4412 !selectOpWithSrcs(ResVReg: T3, ResType, I, Srcs: {Input, MaskReg}, Opcode: AndOp) ||
4413 !selectOpWithSrcs(ResVReg: T4, ResType, I, Srcs: {T3, ShiftReg}, Opcode: ShlOp) ||
4414 !selectOpWithSrcs(ResVReg: Result, ResType, I, Srcs: {T2, T4}, Opcode: OrOp))
4415 return Register();
4416
4417 return Result;
4418 };
4419
4420 unsigned Shift = BitWidth;
4421 Register Result = OpReg;
4422 uint64_t Mask = ~0ull;
4423 while ((Shift >>= 1) > 0) {
4424 Mask ^= (Mask << Shift);
4425 Result = SwapBits(Result, Mask, Shift);
4426 if (!Result.isValid())
4427 return false;
4428 }
4429
4430 return BuildCOPY(DestReg: ResVReg, SrcReg: Result, I);
4431}
4432
4433bool SPIRVInstructionSelector::selectFreeze(Register ResVReg,
4434 SPIRVTypeInst ResType,
4435 MachineInstr &I) const {
4436 assert(I.getOperand(0).isReg() && I.getOperand(1).isReg() &&
4437 "G_FREEZE must define and use a register");
4438 Register OpReg = I.getOperand(i: 1).getReg();
4439
4440 // With SPV_KHR_poison_freeze, lower `freeze` to OpFreezeKHR.
4441 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_poison_freeze)) {
4442 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpFreezeKHR))
4443 .addDef(RegNo: ResVReg)
4444 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4445 .addUse(RegNo: OpReg)
4446 .constrainAllUses(TII, TRI, RBI);
4447 return true;
4448 }
4449
4450 // There is no way to implement `freeze` correctly without support on SPIR-V
4451 // standard side, but we may at least address a simple (static) case when
4452 // undef/poison value presence is obvious. The main benefit of even
4453 // incomplete `freeze` support is preventing of translation from crashing due
4454 // to lack of support on legalization and instruction selection steps.
4455 if (MachineInstr *Def = MRI->getVRegDef(Reg: OpReg)) {
4456 if (Def->getOpcode() == TargetOpcode::COPY)
4457 Def = MRI->getVRegDef(Reg: Def->getOperand(i: 1).getReg());
4458 Register Reg;
4459 switch (Def->getOpcode()) {
4460 case SPIRV::ASSIGN_TYPE:
4461 if (MachineInstr *AssignToDef =
4462 MRI->getVRegDef(Reg: Def->getOperand(i: 1).getReg())) {
4463 if (AssignToDef->getOpcode() == TargetOpcode::G_IMPLICIT_DEF)
4464 Reg = Def->getOperand(i: 2).getReg();
4465 }
4466 break;
4467 case SPIRV::OpUndef:
4468 Reg = Def->getOperand(i: 1).getReg();
4469 break;
4470 }
4471 unsigned DestOpCode;
4472 if (Reg.isValid()) {
4473 DestOpCode = SPIRV::OpConstantNull;
4474 LLVM_DEBUG(dbgs() << "SPV_KHR_poison_freeze is not enabled. freeze of a "
4475 "static undef/poison lowered to OpConstantNull\n");
4476 } else {
4477 DestOpCode = TargetOpcode::COPY;
4478 Reg = OpReg;
4479 LLVM_DEBUG(dbgs() << "SPV_KHR_poison_freeze is not enabled. freeze "
4480 "skipped, lowered as a copy of the operand\n");
4481 }
4482 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: DestOpCode))
4483 .addDef(RegNo: I.getOperand(i: 0).getReg())
4484 .addUse(RegNo: Reg)
4485 .constrainAllUses(TII, TRI, RBI);
4486 return true;
4487 }
4488 return false;
4489}
4490
4491bool SPIRVInstructionSelector::selectBuildVector(Register ResVReg,
4492 SPIRVTypeInst ResType,
4493 MachineInstr &I) const {
4494 unsigned N = 0;
4495 if (isVectorType(SPVTy: ResType))
4496 N = GR.getScalarOrVectorComponentCount(Type: ResType);
4497 else if (ResType->getOpcode() == SPIRV::OpTypeArray)
4498 N = getArrayComponentCount(MRI, ResType);
4499 else
4500 report_fatal_error(reason: "Cannot select G_BUILD_VECTOR with a non-vector result");
4501 if (I.getNumExplicitOperands() - I.getNumExplicitDefs() != N)
4502 report_fatal_error(reason: "G_BUILD_VECTOR and the result type are inconsistent");
4503
4504 // check if we may construct a constant vector
4505 bool IsConst = true;
4506 for (unsigned i = I.getNumExplicitDefs();
4507 i < I.getNumExplicitOperands() && IsConst; ++i)
4508 if (!isConstReg(MRI, OpReg: I.getOperand(i).getReg()))
4509 IsConst = false;
4510
4511 if (!IsConst && (N < 2 && ResType->getOpcode() != SPIRV::OpTypeVectorIdEXT))
4512 return diagnoseUnsupported(
4513 I, Msg: "There must be at least two constituent operands in a vector");
4514
4515 MRI->setRegClass(Reg: ResVReg, RC: GR.getRegClass(SpvType: ResType));
4516
4517 bool IsNullVector = IsConst && !STI.isShader();
4518 for (unsigned i = I.getNumExplicitDefs();
4519 i < I.getNumExplicitOperands() && IsNullVector; ++i) {
4520 MachineInstr *Def = getDef(MO: I.getOperand(i), MRI);
4521 IsNullVector = Def && isNullOrNullSplat(MI: *Def, MRI: *MRI);
4522 }
4523
4524 if (IsNullVector) {
4525 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpConstantNull))
4526 .addDef(RegNo: ResVReg)
4527 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4528 .constrainAllUses(TII, TRI, RBI);
4529 return true;
4530 }
4531
4532 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4533 MCID: TII.get(Opcode: IsConst ? SPIRV::OpConstantComposite
4534 : SPIRV::OpCompositeConstruct))
4535 .addDef(RegNo: ResVReg)
4536 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
4537 for (unsigned i = I.getNumExplicitDefs(); i < I.getNumExplicitOperands(); ++i)
4538 MIB.addUse(RegNo: I.getOperand(i).getReg());
4539 MIB.constrainAllUses(TII, TRI, RBI);
4540 return true;
4541}
4542
4543bool SPIRVInstructionSelector::selectSplatVector(Register ResVReg,
4544 SPIRVTypeInst ResType,
4545 MachineInstr &I) const {
4546 unsigned N = 0;
4547 if (isVectorType(SPVTy: ResType))
4548 N = GR.getScalarOrVectorComponentCount(Type: ResType);
4549 else if (ResType->getOpcode() == SPIRV::OpTypeArray)
4550 N = getArrayComponentCount(MRI, ResType);
4551 else
4552 report_fatal_error(reason: "Cannot select G_SPLAT_VECTOR with a non-vector result");
4553
4554 unsigned OpIdx = I.getNumExplicitDefs();
4555 if (!I.getOperand(i: OpIdx).isReg())
4556 report_fatal_error(reason: "Unexpected argument in G_SPLAT_VECTOR");
4557
4558 // check if we may construct a constant vector
4559 Register OpReg = I.getOperand(i: OpIdx).getReg();
4560 bool IsConst = isConstReg(MRI, OpReg);
4561
4562 if (!IsConst && (N < 2 && ResType->getOpcode() != SPIRV::OpTypeVectorIdEXT))
4563 return diagnoseUnsupported(
4564 I, Msg: "There must be at least two constituent operands in a vector");
4565
4566 MRI->setRegClass(Reg: ResVReg, RC: GR.getRegClass(SpvType: ResType));
4567 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4568 MCID: TII.get(Opcode: IsConst ? SPIRV::OpConstantComposite
4569 : SPIRV::OpCompositeConstruct))
4570 .addDef(RegNo: ResVReg)
4571 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
4572 for (unsigned i = 0; i < N; ++i)
4573 MIB.addUse(RegNo: OpReg);
4574 MIB.constrainAllUses(TII, TRI, RBI);
4575 return true;
4576}
4577
4578bool SPIRVInstructionSelector::selectConcatVectors(Register ResVReg,
4579 SPIRVTypeInst ResType,
4580 MachineInstr &I) const {
4581 // Implement G_CONCAT_VECTORS using OpCompositeConstruct, which allows vector
4582 // constituents that share the result's component type to be
4583 // concatenated in operand order.
4584 if (!isVectorType(SPVTy: ResType))
4585 report_fatal_error(
4586 reason: "Cannot select G_CONCAT_VECTORS with a non-vector result");
4587
4588 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4589 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
4590 .addDef(RegNo: ResVReg)
4591 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
4592 for (unsigned OpIdx = I.getNumExplicitDefs();
4593 OpIdx < I.getNumExplicitOperands(); ++OpIdx)
4594 MIB.addUse(RegNo: I.getOperand(i: OpIdx).getReg());
4595 MIB.constrainAllUses(TII, TRI, RBI);
4596 return true;
4597}
4598
4599bool SPIRVInstructionSelector::selectDiscard(Register ResVReg,
4600 SPIRVTypeInst ResType,
4601 MachineInstr &I) const {
4602
4603 unsigned Opcode;
4604 MachineBasicBlock &BB = *I.getParent();
4605
4606 if (STI.canUseExtension(
4607 E: SPIRV::Extension::SPV_EXT_demote_to_helper_invocation) ||
4608 STI.isAtLeastSPIRVVer(VerToCompareTo: llvm::VersionTuple(1, 6))) {
4609 Opcode = SPIRV::OpDemoteToHelperInvocation;
4610 } else {
4611 Opcode = SPIRV::OpKill;
4612 // OpKill must be the last operation of any basic block.
4613 for (MachineInstr &ToErase : make_early_inc_range(
4614 Range: make_range(x: std::next(x: I.getIterator()), y: BB.instr_end()))) {
4615 GR.invalidateMachineInstr(MI: &ToErase);
4616 ToErase.eraseFromParent();
4617 }
4618 }
4619
4620 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
4621 .constrainAllUses(TII, TRI, RBI);
4622 return true;
4623}
4624
4625bool SPIRVInstructionSelector::selectCmp(Register ResVReg,
4626 SPIRVTypeInst ResType, unsigned CmpOpc,
4627 MachineInstr &I) const {
4628 Register Cmp0 = I.getOperand(i: 2).getReg();
4629 Register Cmp1 = I.getOperand(i: 3).getReg();
4630 assert(GR.getSPIRVTypeForVReg(Cmp0)->getOpcode() ==
4631 GR.getSPIRVTypeForVReg(Cmp1)->getOpcode() &&
4632 "CMP operands should have the same type");
4633 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: CmpOpc))
4634 .addDef(RegNo: ResVReg)
4635 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4636 .addUse(RegNo: Cmp0)
4637 .addUse(RegNo: Cmp1)
4638 .setMIFlags(I.getFlags())
4639 .constrainAllUses(TII, TRI, RBI);
4640 return true;
4641}
4642
4643bool SPIRVInstructionSelector::selectICmp(Register ResVReg,
4644 SPIRVTypeInst ResType,
4645 MachineInstr &I) const {
4646 auto Pred = I.getOperand(i: 1).getPredicate();
4647 unsigned CmpOpc;
4648
4649 Register CmpOperand = I.getOperand(i: 2).getReg();
4650 SPIRVTypeInst CmpOperandType = GR.getSPIRVTypeForVReg(VReg: CmpOperand);
4651 bool IsPtrCmp = CmpOperandType && CmpOperandType.isPointer();
4652 if (IsPtrCmp) {
4653 CmpOpc = getPtrCmpOpcode(Pred);
4654 // OpPtrEqual/OpPtrNotEqual require both operands to share an identical
4655 // pointer type. If they are not OpBitcast is inserted.
4656 Register Op1 = I.getOperand(i: 3).getReg();
4657 SPIRVTypeInst Ty0 = GR.getSPIRVTypeForVReg(VReg: CmpOperand);
4658 if (Ty0 != GR.getSPIRVTypeForVReg(VReg: Op1)) {
4659 Register NewOp1 = createVirtualRegister(SpvType: Ty0, GR: &GR, MRI, MF: MRI->getMF());
4660 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBitcast))
4661 .addDef(RegNo: NewOp1)
4662 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: Ty0))
4663 .addUse(RegNo: Op1)
4664 .constrainAllUses(TII, TRI, RBI);
4665 I.getOperand(i: 3).setReg(NewOp1);
4666 }
4667 } else if (GR.isScalarOrVectorOfType(VReg: CmpOperand, TypeOpcode: SPIRV::OpTypeBool))
4668 CmpOpc = getBoolCmpOpcode(PredNum: Pred);
4669 else
4670 CmpOpc = getICmpOpcode(PredNum: Pred);
4671 return selectCmp(ResVReg, ResType, CmpOpc, I);
4672}
4673
4674// Always inserts the constant definition in the entry block so it dominates all
4675// uses regardless of block ordering.
4676Register SPIRVInstructionSelector::buildI32ConstantInEntryBlock(
4677 uint32_t Val, MachineInstr &I, SPIRVTypeInst ResType) const {
4678 Type *LLVMTy = IntegerType::get(C&: GR.CurMF->getFunction().getContext(), NumBits: 32);
4679 SPIRVTypeInst SpvI32Ty =
4680 ResType ? ResType : GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
4681 auto *ConstInt = ConstantInt::get(Ty: LLVMTy, V: Val);
4682 Register NewReg = GR.find(V: ConstInt, MF: GR.CurMF);
4683 if (!NewReg.isValid()) {
4684 NewReg = MRI->createGenericVirtualRegister(Ty: LLT::scalar(SizeInBits: 64));
4685 auto InsertIt = getOpVariableMBBIt(MF&: *I.getMF());
4686 MachineBasicBlock &EntryBB = *InsertIt->getParent();
4687 MachineInstr *MI = nullptr;
4688 Register TypeReg = GR.getSPIRVTypeID(SpirvType: SpvI32Ty);
4689 DebugLoc DbgLoc = I.getDebugLoc();
4690 if (Val == 0) {
4691 MI = BuildMI(BB&: EntryBB, I: InsertIt, MIMD: DbgLoc, MCID: TII.get(Opcode: SPIRV::OpConstantNull))
4692 .addDef(RegNo: NewReg)
4693 .addUse(RegNo: TypeReg);
4694 } else {
4695 uint64_t ImmVal = APInt(32, Val).getZExtValue();
4696 MI = BuildMI(BB&: EntryBB, I: InsertIt, MIMD: DbgLoc, MCID: TII.get(Opcode: SPIRV::OpConstantI))
4697 .addDef(RegNo: NewReg)
4698 .addUse(RegNo: TypeReg)
4699 .addImm(Val: ImmVal);
4700 }
4701 constrainSelectedInstRegOperands(I&: *MI, TII, TRI, RBI);
4702 GR.add(V: ConstInt, MI);
4703 }
4704 return NewReg;
4705}
4706
4707bool SPIRVInstructionSelector::selectFCmp(Register ResVReg,
4708 SPIRVTypeInst ResType,
4709 MachineInstr &I) const {
4710 auto Pred = I.getOperand(i: 1).getPredicate();
4711 // OpOrdered and OpUnordered require the Kernel capability. For shaders,
4712 // express them as uno(a, b) = isnan(a) || isnan(b), ord(a, b) = !uno(a, b).
4713 if (STI.isShader() &&
4714 (Pred == CmpInst::FCMP_ORD || Pred == CmpInst::FCMP_UNO)) {
4715 MachineBasicBlock &BB = *I.getParent();
4716 Register ResTypeID = GR.getSPIRVTypeID(SpirvType: ResType);
4717 Register IsNan[2];
4718 for (unsigned Idx = 0; Idx < 2; ++Idx) {
4719 IsNan[Idx] = createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: *I.getMF());
4720 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIsNan))
4721 .addDef(RegNo: IsNan[Idx])
4722 .addUse(RegNo: ResTypeID)
4723 .addUse(RegNo: I.getOperand(i: 2 + Idx).getReg())
4724 .constrainAllUses(TII, TRI, RBI);
4725 }
4726 Register UnoReg =
4727 Pred == CmpInst::FCMP_UNO
4728 ? ResVReg
4729 : createVirtualRegister(SpvType: ResType, GR: &GR, MRI, MF: *I.getMF());
4730 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLogicalOr))
4731 .addDef(RegNo: UnoReg)
4732 .addUse(RegNo: ResTypeID)
4733 .addUse(RegNo: IsNan[0])
4734 .addUse(RegNo: IsNan[1])
4735 .constrainAllUses(TII, TRI, RBI);
4736 if (Pred == CmpInst::FCMP_ORD)
4737 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLogicalNot))
4738 .addDef(RegNo: ResVReg)
4739 .addUse(RegNo: ResTypeID)
4740 .addUse(RegNo: UnoReg)
4741 .constrainAllUses(TII, TRI, RBI);
4742 return true;
4743 }
4744 unsigned CmpOp = getFCmpOpcode(PredNum: Pred);
4745 return selectCmp(ResVReg, ResType, CmpOpc: CmpOp, I);
4746}
4747
4748bool SPIRVInstructionSelector::selectExp10(Register ResVReg,
4749 SPIRVTypeInst ResType,
4750 MachineInstr &I) const {
4751 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std)) {
4752 return selectExtInst(ResVReg, ResType, I, CLInst: CL::exp10);
4753 }
4754
4755 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::GLSL_std_450)) {
4756 /// There is no exp10 in GLSL. Use exp10(x) = exp2(x * log2(10)) instead
4757 /// log2(10) ~= 3.3219280948874l
4758
4759 if (!isVectorType(SPVTy: ResType) && !ResType.isAnyTypeFloat())
4760 return false;
4761
4762 MachineIRBuilder MIRBuilder(I);
4763
4764 SPIRVTypeInst SpirvScalarType = GR.getScalarOrVectorComponentType(Type: ResType);
4765
4766 // Match the literal precision to the scalar type so the OpConstant
4767 // literal does not contain non-zero high-order bits that would fail
4768 // SPIR-V validation when the type is narrower than 32 bits (e.g. half).
4769 APFloat ConstVal(3.3219280948873623);
4770 bool LosesInfo;
4771 ConstVal.convert(
4772 ToSemantics: getZeroFP(LLVMFloatTy: GR.getTypeForSPIRVType(Ty: SpirvScalarType)).getSemantics(),
4773 RM: APFloat::rmNearestTiesToEven, losesInfo: &LosesInfo);
4774 Register ConstReg =
4775 GR.buildConstantFP(Val: ConstVal, MIRBuilder, SpvType: SpirvScalarType);
4776 Register ArgReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
4777 auto Opcode =
4778 isVectorType(SPVTy: ResType) ? SPIRV::OpVectorTimesScalar : SPIRV::OpFMulS;
4779
4780 if (!selectOpWithSrcs(ResVReg: ArgReg, ResType, I,
4781 Srcs: {I.getOperand(i: 1).getReg(), ConstReg}, Opcode))
4782 return false;
4783 if (!selectExtInst(ResVReg, ResType, I,
4784 Insts: {{SPIRV::InstructionSet::GLSL_std_450, GL::Exp2}}, setMIFlags: false,
4785 useMISrc: false, SrcRegs: {ArgReg}))
4786 return false;
4787
4788 return true;
4789 }
4790
4791 return false;
4792}
4793
4794Register SPIRVInstructionSelector::buildZerosVal(SPIRVTypeInst ResType,
4795 MachineInstr &I) const {
4796 // OpenCL uses nulls for Zero. In HLSL we don't use null constants.
4797 bool ZeroAsNull = !STI.isShader();
4798 if (isVectorType(SPVTy: ResType))
4799 return GR.getOrCreateConstVector(Val: 0UL, I, SpvType: ResType, TII, ZeroAsNull);
4800 return GR.getOrCreateConstInt(Val: 0, I, SpvType: ResType, TII, ZeroAsNull);
4801}
4802
4803bool SPIRVInstructionSelector::isScalarOrVectorIntConstantZero(
4804 Register Reg) const {
4805 SPIRVTypeInst Type = GR.getSPIRVTypeForVReg(VReg: Reg);
4806 if (!Type)
4807 return false;
4808 SPIRVTypeInst CompType = GR.getScalarOrVectorComponentType(Type);
4809 if (!CompType || CompType->getOpcode() != SPIRV::OpTypeInt)
4810 return false;
4811
4812 auto IsZero = [this](Register Reg) {
4813 MachineInstr *Def = getDefInstrMaybeConstant(ConstReg&: Reg, MRI);
4814 if (!Def)
4815 return false;
4816
4817 if (Def->getOpcode() == SPIRV::OpConstantNull)
4818 return true;
4819
4820 if (Def->getOpcode() == TargetOpcode::G_CONSTANT ||
4821 Def->getOpcode() == SPIRV::OpConstantI)
4822 return getIConstVal(ConstReg: Reg, MRI) == 0;
4823
4824 return false;
4825 };
4826
4827 if (IsZero(Reg))
4828 return true;
4829
4830 MachineInstr *Def = MRI->getVRegDef(Reg);
4831 if (!Def)
4832 return false;
4833
4834 if (Def->getOpcode() == TargetOpcode::G_BUILD_VECTOR ||
4835 (Def->getOpcode() == TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS &&
4836 cast<GIntrinsic>(Val: Def)->getIntrinsicID() ==
4837 Intrinsic::spv_const_composite)) {
4838 unsigned StartOp = Def->getOpcode() == TargetOpcode::G_BUILD_VECTOR ? 1 : 2;
4839 for (unsigned i = StartOp; i < Def->getNumOperands(); ++i) {
4840 if (!IsZero(Def->getOperand(i).getReg()))
4841 return false;
4842 }
4843 return true;
4844 }
4845
4846 return false;
4847}
4848
4849Register SPIRVInstructionSelector::buildZerosValF(SPIRVTypeInst ResType,
4850 MachineInstr &I) const {
4851 // OpenCL uses nulls for Zero. In HLSL we don't use null constants.
4852 bool ZeroAsNull = !STI.isShader();
4853 APFloat VZero = getZeroFP(LLVMFloatTy: GR.getTypeForSPIRVType(Ty: ResType));
4854 if (isVectorType(SPVTy: ResType))
4855 return GR.getOrCreateConstVector(Val: VZero, I, SpvType: ResType, TII, ZeroAsNull);
4856 return GR.getOrCreateConstFP(Val: VZero, I, SpvType: ResType, TII, ZeroAsNull);
4857}
4858
4859Register SPIRVInstructionSelector::buildOnesValF(SPIRVTypeInst ResType,
4860 MachineInstr &I) const {
4861 // OpenCL uses nulls for Zero. In HLSL we don't use null constants.
4862 bool ZeroAsNull = !STI.isShader();
4863 APFloat VOne = getOneFP(LLVMFloatTy: GR.getTypeForSPIRVType(Ty: ResType));
4864 if (isVectorType(SPVTy: ResType))
4865 return GR.getOrCreateConstVector(Val: VOne, I, SpvType: ResType, TII, ZeroAsNull);
4866 return GR.getOrCreateConstFP(Val: VOne, I, SpvType: ResType, TII, ZeroAsNull);
4867}
4868
4869Register SPIRVInstructionSelector::buildOnesVal(bool AllOnes,
4870 SPIRVTypeInst ResType,
4871 MachineInstr &I) const {
4872 unsigned BitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
4873 APInt One =
4874 AllOnes ? APInt::getAllOnes(numBits: BitWidth) : APInt::getOneBitSet(numBits: BitWidth, BitNo: 0);
4875 if (isVectorType(SPVTy: ResType))
4876 return GR.getOrCreateConstVector(Val: One, I, SpvType: ResType, TII);
4877 return GR.getOrCreateConstInt(Val: One, I, SpvType: ResType, TII);
4878}
4879
4880Register SPIRVInstructionSelector::buildVectorSplat(Register ScalarReg,
4881 unsigned NumElts,
4882 MachineInstr &I) const {
4883 SPIRVTypeInst VecType = GR.getOrCreateSPIRVVectorType(
4884 BaseType: GR.getSPIRVTypeForVReg(VReg: ScalarReg), NumElements: NumElts, I, TII);
4885 Register SplatReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: VecType));
4886 GR.assignSPIRVTypeToVReg(Type: VecType, VReg: SplatReg, MF: MRI->getMF());
4887 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
4888 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
4889 .addDef(RegNo: SplatReg)
4890 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: VecType));
4891 for (unsigned J = 0; J < NumElts; ++J)
4892 MIB.addUse(RegNo: ScalarReg);
4893 MIB.constrainAllUses(TII, TRI, RBI);
4894 return SplatReg;
4895}
4896
4897bool SPIRVInstructionSelector::selectSelect(Register ResVReg,
4898 SPIRVTypeInst ResType,
4899 MachineInstr &I) const {
4900 Register SelectFirstArg = I.getOperand(i: 2).getReg();
4901 Register SelectSecondArg = I.getOperand(i: 3).getReg();
4902 assert(ResType == GR.getSPIRVTypeForVReg(SelectFirstArg) &&
4903 ResType == GR.getSPIRVTypeForVReg(SelectSecondArg));
4904
4905 bool IsFloatTy =
4906 GR.isScalarOrVectorOfType(VReg: SelectFirstArg, TypeOpcode: SPIRV::OpTypeFloat);
4907 bool IsPtrTy = GR.getScalarOrVectorComponentType(Type: ResType).isPointer();
4908
4909 Register CondReg = I.getOperand(i: 1).getReg();
4910 bool IsScalarBool = GR.isScalarOfType(VReg: CondReg, TypeOpcode: SPIRV::OpTypeBool);
4911 unsigned Opcode;
4912 if (isVectorType(SPVTy: GR.getSPIRVTypeForVReg(VReg: SelectFirstArg))) {
4913 // Before SPIR-V 1.4, the condition of an OpSelect with a vector result
4914 // must be a vector of Booleans with the same number of components, while
4915 // LLVM IR also allows a scalar i1 condition. Splat it in that case.
4916 if (IsScalarBool && !STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 4))) {
4917 unsigned NumElts = GR.getScalarOrVectorComponentCount(Type: ResType);
4918 CondReg = buildVectorSplat(ScalarReg: CondReg, NumElts, I);
4919 IsScalarBool = false;
4920 }
4921 if (IsFloatTy) {
4922 Opcode = IsScalarBool ? SPIRV::OpSelectVFSCond : SPIRV::OpSelectVFVCond;
4923 } else if (IsPtrTy) {
4924 Opcode = IsScalarBool ? SPIRV::OpSelectVPSCond : SPIRV::OpSelectVPVCond;
4925 } else {
4926 Opcode = IsScalarBool ? SPIRV::OpSelectVISCond : SPIRV::OpSelectVIVCond;
4927 }
4928 } else {
4929 assert(IsScalarBool && "OpSelect with a scalar result requires a scalar "
4930 "boolean condition");
4931 if (IsFloatTy) {
4932 Opcode = SPIRV::OpSelectSFSCond;
4933 } else if (IsPtrTy) {
4934 Opcode = SPIRV::OpSelectSPSCond;
4935 } else {
4936 Opcode = SPIRV::OpSelectSISCond;
4937 }
4938 }
4939 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
4940 .addDef(RegNo: ResVReg)
4941 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4942 .addUse(RegNo: CondReg)
4943 .addUse(RegNo: SelectFirstArg)
4944 .addUse(RegNo: SelectSecondArg)
4945 .constrainAllUses(TII, TRI, RBI);
4946 return true;
4947}
4948
4949// This function is used to extend a bool or a vector of bools into an integer
4950// or vector of integers.
4951bool SPIRVInstructionSelector::selectBoolToInt(Register ResVReg,
4952 SPIRVTypeInst ResType,
4953 Register BooleanVReg,
4954 MachineInstr &InsertAt,
4955 bool IsSigned) const {
4956 // To extend a bool, we need to use OpSelect between constants.
4957 Register ZeroReg = buildZerosVal(ResType, I&: InsertAt);
4958 Register OneReg = buildOnesVal(AllOnes: IsSigned, ResType, I&: InsertAt);
4959 bool IsScalarBool = GR.isScalarOfType(VReg: BooleanVReg, TypeOpcode: SPIRV::OpTypeBool);
4960 unsigned Opcode =
4961 IsScalarBool ? SPIRV::OpSelectSISCond : SPIRV::OpSelectVIVCond;
4962 BuildMI(BB&: *InsertAt.getParent(), I&: InsertAt, MIMD: InsertAt.getDebugLoc(),
4963 MCID: TII.get(Opcode))
4964 .addDef(RegNo: ResVReg)
4965 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
4966 .addUse(RegNo: BooleanVReg)
4967 .addUse(RegNo: OneReg)
4968 .addUse(RegNo: ZeroReg)
4969 .constrainAllUses(TII, TRI, RBI);
4970 return true;
4971}
4972
4973bool SPIRVInstructionSelector::selectIToF(Register ResVReg,
4974 SPIRVTypeInst ResType,
4975 MachineInstr &I, bool IsSigned,
4976 unsigned Opcode) const {
4977 Register SrcReg = I.getOperand(i: 1).getReg();
4978 // We can convert bool value directly to float type without OpConvert*ToF,
4979 // however the translator generates OpSelect+OpConvert*ToF, so we do the same.
4980 if (GR.isScalarOrVectorOfType(VReg: I.getOperand(i: 1).getReg(), TypeOpcode: SPIRV::OpTypeBool)) {
4981 unsigned BitWidth = GR.getScalarOrVectorBitWidth(Type: ResType);
4982 SPIRVTypeInst TmpType = GR.getOrCreateSPIRVIntegerType(BitWidth, I, TII);
4983 if (isVectorType(SPVTy: ResType)) {
4984 const unsigned NumElts = GR.getScalarOrVectorComponentCount(Type: ResType);
4985 TmpType = GR.getOrCreateSPIRVVectorType(BaseType: TmpType, NumElements: NumElts, I, TII);
4986 }
4987 SrcReg = createVirtualRegister(SpvType: TmpType, GR: &GR, MRI, MF: MRI->getMF());
4988 selectBoolToInt(ResVReg: SrcReg, ResType: TmpType, BooleanVReg: I.getOperand(i: 1).getReg(), InsertAt&: I, IsSigned);
4989 }
4990 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {SrcReg}, Opcode);
4991}
4992
4993bool SPIRVInstructionSelector::selectExt(Register ResVReg,
4994 SPIRVTypeInst ResType, MachineInstr &I,
4995 bool IsSigned) const {
4996 Register SrcReg = I.getOperand(i: 1).getReg();
4997 if (GR.isScalarOrVectorOfType(VReg: SrcReg, TypeOpcode: SPIRV::OpTypeBool))
4998 return selectBoolToInt(ResVReg, ResType, BooleanVReg: I.getOperand(i: 1).getReg(), InsertAt&: I,
4999 IsSigned);
5000
5001 SPIRVTypeInst SrcType = GR.getSPIRVTypeForVReg(VReg: SrcReg);
5002 if (ResType == SrcType)
5003 return BuildCOPY(DestReg: ResVReg, SrcReg, I);
5004
5005 unsigned Opcode = IsSigned ? SPIRV::OpSConvert : SPIRV::OpUConvert;
5006 return selectUnOp(ResVReg, ResType, I, Opcode);
5007}
5008
5009bool SPIRVInstructionSelector::selectSUCmp(Register ResVReg,
5010 SPIRVTypeInst ResType,
5011 MachineInstr &I,
5012 bool IsSigned) const {
5013 MachineIRBuilder MIRBuilder(I);
5014 MachineRegisterInfo *MRI = MIRBuilder.getMRI();
5015 MachineBasicBlock &BB = *I.getParent();
5016 // Ensure we have bool.
5017 SPIRVTypeInst BoolType = GR.getOrCreateSPIRVBoolType(I, TII);
5018 unsigned N = GR.getScalarOrVectorComponentCount(Type: ResType);
5019 if (N > 1 || (ResType->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
5020 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector)))
5021 BoolType = GR.getOrCreateSPIRVVectorType(BaseType: BoolType, NumElements: N, I, TII);
5022 Register BoolTypeReg = GR.getSPIRVTypeID(SpirvType: BoolType);
5023 // Build less-than-equal and less-than.
5024 Register IsLessEqReg =
5025 createVirtualRegister(SpvType: BoolType, GR: &GR, MRI, MF: MIRBuilder.getMF());
5026 BuildMI(BB, I, MIMD: I.getDebugLoc(),
5027 MCID: TII.get(Opcode: IsSigned ? SPIRV::OpSLessThanEqual : SPIRV::OpULessThanEqual))
5028 .addDef(RegNo: IsLessEqReg)
5029 .addUse(RegNo: BoolTypeReg)
5030 .addUse(RegNo: I.getOperand(i: 1).getReg())
5031 .addUse(RegNo: I.getOperand(i: 2).getReg())
5032 .constrainAllUses(TII, TRI, RBI);
5033 Register IsLessReg =
5034 createVirtualRegister(SpvType: BoolType, GR: &GR, MRI, MF: MIRBuilder.getMF());
5035 BuildMI(BB, I, MIMD: I.getDebugLoc(),
5036 MCID: TII.get(Opcode: IsSigned ? SPIRV::OpSLessThan : SPIRV::OpULessThan))
5037 .addDef(RegNo: IsLessReg)
5038 .addUse(RegNo: BoolTypeReg)
5039 .addUse(RegNo: I.getOperand(i: 1).getReg())
5040 .addUse(RegNo: I.getOperand(i: 2).getReg())
5041 .constrainAllUses(TII, TRI, RBI);
5042 // Build selects.
5043 Register ResTypeReg = GR.getSPIRVTypeID(SpirvType: ResType);
5044 Register NegOneOrZeroReg =
5045 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
5046 MRI->setType(VReg: NegOneOrZeroReg, Ty: LLT::scalar(SizeInBits: 64));
5047 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: NegOneOrZeroReg, MF: MIRBuilder.getMF());
5048 unsigned SelectOpcode =
5049 (N > 1 || (ResType->getOpcode() == SPIRV::OpTypeVectorIdEXT &&
5050 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector)))
5051 ? SPIRV::OpSelectVIVCond
5052 : SPIRV::OpSelectSISCond;
5053 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SelectOpcode))
5054 .addDef(RegNo: NegOneOrZeroReg)
5055 .addUse(RegNo: ResTypeReg)
5056 .addUse(RegNo: IsLessReg)
5057 .addUse(RegNo: buildOnesVal(AllOnes: true, ResType, I)) // -1
5058 .addUse(RegNo: buildZerosVal(ResType, I))
5059 .constrainAllUses(TII, TRI, RBI);
5060 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SelectOpcode))
5061 .addDef(RegNo: ResVReg)
5062 .addUse(RegNo: ResTypeReg)
5063 .addUse(RegNo: IsLessEqReg)
5064 .addUse(RegNo: NegOneOrZeroReg) // -1 or 0
5065 .addUse(RegNo: buildOnesVal(AllOnes: false, ResType, I))
5066 .constrainAllUses(TII, TRI, RBI);
5067 return true;
5068}
5069
5070bool SPIRVInstructionSelector::selectIntToBool(Register IntReg,
5071 Register ResVReg,
5072 MachineInstr &I,
5073 SPIRVTypeInst IntTy,
5074 SPIRVTypeInst BoolTy) const {
5075 // To truncate to a bool, we use OpBitwiseAnd 1 and OpINotEqual to zero.
5076 Register BitIntReg = createVirtualRegister(SpvType: IntTy, GR: &GR, MRI, MF: MRI->getMF());
5077 unsigned Opcode =
5078 isVectorType(SPVTy: IntTy) ? SPIRV::OpBitwiseAndV : SPIRV::OpBitwiseAndS;
5079 Register Zero = buildZerosVal(ResType: IntTy, I);
5080 Register One = buildOnesVal(AllOnes: false, ResType: IntTy, I);
5081 MachineBasicBlock &BB = *I.getParent();
5082 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
5083 .addDef(RegNo: BitIntReg)
5084 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: IntTy))
5085 .addUse(RegNo: IntReg)
5086 .addUse(RegNo: One)
5087 .constrainAllUses(TII, TRI, RBI);
5088 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpINotEqual))
5089 .addDef(RegNo: ResVReg)
5090 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: BoolTy))
5091 .addUse(RegNo: BitIntReg)
5092 .addUse(RegNo: Zero)
5093 .constrainAllUses(TII, TRI, RBI);
5094 return true;
5095}
5096
5097bool SPIRVInstructionSelector::selectTrunc(Register ResVReg,
5098 SPIRVTypeInst ResType,
5099 MachineInstr &I) const {
5100 Register IntReg = I.getOperand(i: 1).getReg();
5101 const SPIRVTypeInst ArgType = GR.getSPIRVTypeForVReg(VReg: IntReg);
5102 if (GR.isScalarOrVectorOfType(VReg: ResVReg, TypeOpcode: SPIRV::OpTypeBool))
5103 return selectIntToBool(IntReg, ResVReg, I, IntTy: ArgType, BoolTy: ResType);
5104 if (ArgType == ResType)
5105 return BuildCOPY(DestReg: ResVReg, SrcReg: IntReg, I);
5106 bool IsSigned = GR.isScalarOrVectorSigned(Type: ResType);
5107 unsigned Opcode = IsSigned ? SPIRV::OpSConvert : SPIRV::OpUConvert;
5108 return selectUnOp(ResVReg, ResType, I, Opcode);
5109}
5110
5111bool SPIRVInstructionSelector::selectConst(Register ResVReg,
5112 SPIRVTypeInst ResType,
5113 MachineInstr &I) const {
5114 unsigned Opcode = I.getOpcode();
5115 unsigned TpOpcode = ResType->getOpcode();
5116 Register Reg;
5117 if (ResType.isPointer() || TpOpcode == SPIRV::OpTypeEvent) {
5118 assert(Opcode == TargetOpcode::G_CONSTANT &&
5119 I.getOperand(1).getCImm()->isZero());
5120 MachineBasicBlock &DepMBB = I.getMF()->front();
5121 MachineIRBuilder MIRBuilder(DepMBB, DepMBB.getFirstNonPHI());
5122 Reg = GR.getOrCreateConstNullPtr(MIRBuilder, SpvType: ResType);
5123 } else if (TpOpcode == SPIRV::OpTypeVectorIdEXT) {
5124 // We ended up here coming from a splat on a <1 x T> type, which
5125 // IRTranslator translated into a scalar, so we have to restore the
5126 // vectorness.
5127 assert(GR.getScalarOrVectorComponentCount(ResType) == 1 &&
5128 "Expected <1 x T> Vector!");
5129 if (Opcode == TargetOpcode::G_FCONSTANT)
5130 Reg = GR.getOrCreateConstVector(Val: I.getOperand(i: 1).getFPImm()->getValue(), I,
5131 SpvType: ResType, TII);
5132 else // We handle vector of pointer here as well.
5133 Reg = GR.getOrCreateConstVector(Val: I.getOperand(i: 1).getCImm()->getValue(), I,
5134 SpvType: ResType, TII);
5135 } else if (Opcode == TargetOpcode::G_FCONSTANT) {
5136 Reg = GR.getOrCreateConstFP(Val: I.getOperand(i: 1).getFPImm()->getValue(), I,
5137 SpvType: ResType, TII, ZeroAsNull: !STI.isShader());
5138
5139 } else {
5140 Reg = GR.getOrCreateConstInt(Val: I.getOperand(i: 1).getCImm()->getValue(), I,
5141 SpvType: ResType, TII, ZeroAsNull: !STI.isShader());
5142 }
5143 return Reg == ResVReg ? true : BuildCOPY(DestReg: ResVReg, SrcReg: Reg, I);
5144}
5145
5146bool SPIRVInstructionSelector::selectOpUndef(Register ResVReg,
5147 SPIRVTypeInst ResType,
5148 MachineInstr &I) const {
5149 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUndef))
5150 .addDef(RegNo: ResVReg)
5151 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5152 .constrainAllUses(TII, TRI, RBI);
5153 return true;
5154}
5155
5156bool SPIRVInstructionSelector::selectInsertVal(Register ResVReg,
5157 SPIRVTypeInst ResType,
5158 MachineInstr &I) const {
5159 MachineBasicBlock &BB = *I.getParent();
5160 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeInsert))
5161 .addDef(RegNo: ResVReg)
5162 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5163 // object to insert
5164 .addUse(RegNo: I.getOperand(i: 3).getReg())
5165 // composite to insert into
5166 .addUse(RegNo: I.getOperand(i: 2).getReg());
5167 for (unsigned i = 4; i < I.getNumOperands(); i++)
5168 MIB.addImm(Val: foldImm(MO: I.getOperand(i), MRI));
5169 MIB.constrainAllUses(TII, TRI, RBI);
5170 return true;
5171}
5172
5173bool SPIRVInstructionSelector::selectExtractVal(Register ResVReg,
5174 SPIRVTypeInst ResType,
5175 MachineInstr &I) const {
5176 Type *MaybeResTy = nullptr;
5177 StringRef ResName;
5178 if (GR.findValueAttrs(Key: &I, Ty&: MaybeResTy, Name&: ResName) &&
5179 MaybeResTy != GR.getTypeForSPIRVType(Ty: ResType)) {
5180 assert((!MaybeResTy || MaybeResTy->isAggregateType()) &&
5181 "Expected aggregate type for extractv instruction");
5182 ResType = GR.getOrCreateSPIRVType(Type: MaybeResTy, I,
5183 AQ: SPIRV::AccessQualifier::ReadWrite, EmitIR: false);
5184 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: ResVReg, MF: *I.getMF());
5185 }
5186 MachineBasicBlock &BB = *I.getParent();
5187 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
5188 .addDef(RegNo: ResVReg)
5189 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5190 .addUse(RegNo: I.getOperand(i: 2).getReg());
5191 for (unsigned i = 3; i < I.getNumOperands(); i++)
5192 MIB.addImm(Val: foldImm(MO: I.getOperand(i), MRI));
5193 MIB.constrainAllUses(TII, TRI, RBI);
5194 return true;
5195}
5196
5197bool SPIRVInstructionSelector::selectInsertElt(Register ResVReg,
5198 SPIRVTypeInst ResType,
5199 MachineInstr &I) const {
5200 if (getImm(MO: I.getOperand(i: 4), MRI))
5201 return selectInsertVal(ResVReg, ResType, I);
5202 MachineBasicBlock &BB = *I.getParent();
5203 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpVectorInsertDynamic))
5204 .addDef(RegNo: ResVReg)
5205 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5206 .addUse(RegNo: I.getOperand(i: 2).getReg())
5207 .addUse(RegNo: I.getOperand(i: 3).getReg())
5208 .addUse(RegNo: I.getOperand(i: 4).getReg())
5209 .constrainAllUses(TII, TRI, RBI);
5210 return true;
5211}
5212
5213bool SPIRVInstructionSelector::selectExtractElt(Register ResVReg,
5214 SPIRVTypeInst ResType,
5215 MachineInstr &I) const {
5216 if (getImm(MO: I.getOperand(i: 3), MRI))
5217 return selectExtractVal(ResVReg, ResType, I);
5218 MachineBasicBlock &BB = *I.getParent();
5219 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpVectorExtractDynamic))
5220 .addDef(RegNo: ResVReg)
5221 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5222 .addUse(RegNo: I.getOperand(i: 2).getReg())
5223 .addUse(RegNo: I.getOperand(i: 3).getReg())
5224 .constrainAllUses(TII, TRI, RBI);
5225 return true;
5226}
5227
5228bool SPIRVInstructionSelector::selectGEP(Register ResVReg,
5229 SPIRVTypeInst ResType,
5230 MachineInstr &I) const {
5231 const bool IsGEPInBounds = I.getOperand(i: 2).getImm();
5232 // Pointers to opaque types stay typed even with the extension on, so emit the
5233 // untyped variant only when the result is actually an untyped pointer.
5234 const bool UseUntypedPointers =
5235 ResType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
5236
5237 // Determine the opcode based on pointer type and bounds checking.
5238 // When using untyped pointers, use OpUntyped*AccessChainKHR variants.
5239 unsigned Opcode;
5240 if (UseUntypedPointers) {
5241 if (STI.isLogicalSPIRV()) {
5242 Opcode = IsGEPInBounds ? SPIRV::OpUntypedInBoundsAccessChainKHR
5243 : SPIRV::OpUntypedAccessChainKHR;
5244 } else {
5245 Opcode = IsGEPInBounds ? SPIRV::OpUntypedInBoundsPtrAccessChainKHR
5246 : SPIRV::OpUntypedPtrAccessChainKHR;
5247 }
5248 } else {
5249 // OpAccessChain could be used for OpenCL, but the SPIRV-LLVM Translator
5250 // only relies on PtrAccessChain, so we'll try not to deviate. For Vulkan
5251 // however, we have to use Op[InBounds]AccessChain.
5252 // FIXME: fix llvm-spirv.
5253 if (STI.isLogicalSPIRV()) {
5254 Opcode =
5255 IsGEPInBounds ? SPIRV::OpInBoundsAccessChain : SPIRV::OpAccessChain;
5256 } else {
5257 Opcode = IsGEPInBounds ? SPIRV::OpInBoundsPtrAccessChain
5258 : SPIRV::OpPtrAccessChain;
5259 }
5260 }
5261
5262 Register BaseReg = I.getOperand(i: 3).getReg();
5263 auto Res = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
5264 .addDef(RegNo: ResVReg)
5265 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
5266
5267 // For untyped access chains, we need to add the base type operand.
5268 if (UseUntypedPointers) {
5269 // Get the element type from the base pointer register.
5270 // For untyped pointers, this was stored when processing
5271 // spv_assign_ptr_type.
5272 SPIRVTypeInst BaseType = GR.getUntypedPtrElementType(Reg: BaseReg);
5273 if (!BaseType) {
5274 // Otherwise try the pointee type for mixed typed-pointer usage.
5275 SPIRVTypeInst BasePtrType = GR.getSPIRVTypeForVReg(VReg: BaseReg);
5276 BaseType = BasePtrType ? GR.getPointeeType(PtrType: BasePtrType) : nullptr;
5277 }
5278 if (!BaseType) {
5279 // The base may be a not-yet-selected global. Read its value type from
5280 // the defining G_GLOBAL_VALUE, following copies.
5281 Register DefReg = BaseReg;
5282 MachineInstr *Def = MRI->getVRegDef(Reg: DefReg);
5283 while (Def && Def->getOpcode() == TargetOpcode::COPY &&
5284 Def->getOperand(i: 1).isReg())
5285 Def = MRI->getVRegDef(Reg: Def->getOperand(i: 1).getReg());
5286 if (Def && Def->getOpcode() == TargetOpcode::G_GLOBAL_VALUE)
5287 if (const auto *GVar =
5288 dyn_cast<GlobalVariable>(Val: Def->getOperand(i: 1).getGlobal()))
5289 BaseType = GR.getOrCreateSPIRVType(Type: GVar->getValueType(), I,
5290 AQ: SPIRV::AccessQualifier::ReadWrite,
5291 /*EmitIR=*/false);
5292 }
5293 if (!BaseType)
5294 return diagnoseUnsupported(
5295 I, Msg: "could not deduce the base type of an untyped access chain");
5296 Res.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: BaseType));
5297 }
5298
5299 // Object to get a pointer to.
5300 Res.addUse(RegNo: BaseReg);
5301
5302 const bool IsAccessChainOpcode =
5303 (Opcode == SPIRV::OpAccessChain ||
5304 Opcode == SPIRV::OpInBoundsAccessChain ||
5305 Opcode == SPIRV::OpUntypedAccessChainKHR ||
5306 Opcode == SPIRV::OpUntypedInBoundsAccessChainKHR);
5307
5308 assert((!IsAccessChainOpcode || (getImm(I.getOperand(4), MRI) &&
5309 foldImm(I.getOperand(4), MRI) == 0)) &&
5310 "Cannot translate GEP to OpAccessChain.");
5311
5312 // Adding indices.
5313 const unsigned StartingIndex = IsAccessChainOpcode ? 5 : 4;
5314 for (unsigned i = StartingIndex; i < I.getNumExplicitOperands(); ++i)
5315 Res.addUse(RegNo: I.getOperand(i).getReg());
5316 Res.constrainAllUses(TII, TRI, RBI);
5317
5318 // IRTranslator doesn't like <1 x T> vectors, and treats them as scalars. This
5319 // creates an information loss issue, and also broken code where a
5320 // OpCompositeExtract is applied to the scalar return of an OpPtrAccessChain,
5321 // when it was meant to be applied to the OpCompositeInsert created <1 x T>.
5322 // TODO: should we also re-create the index <1 x T>?
5323 if (MRI->hasOneUse(RegNo: ResVReg)) {
5324 MachineInstr &Extract = *MRI->use_instr_begin(RegNo: ResVReg);
5325 if (Extract.getOpcode() == SPIRV::OpCompositeExtract) {
5326 SPIRVTypeInst V = GR.getOrCreateSPIRVVectorType(BaseType: ResType, NumElements: 1, I&: Extract, TII);
5327 // We cannot use GlobalRegistry::getOrCreateUndef directly here because it
5328 // tries to use UndefVal::get, which does not work for TypedPointerType,
5329 // which we can get here if we're dealing with <1 x T*>.
5330 Register Tmp = createVirtualRegister(SpvType: V, GR: &GR, MRI, MF: *I.getMF());
5331 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUndef))
5332 .addDef(RegNo: Tmp)
5333 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: V))
5334 .constrainAllUses(TII, TRI, RBI);
5335 Register InsertReg = createVirtualRegister(SpvType: V, GR: &GR, MRI, MF: *I.getMF());
5336 BuildMI(BB&: *I.getParent(), I&: Extract, MIMD: Extract.getDebugLoc(),
5337 MCID: TII.get(Opcode: SPIRV::OpCompositeInsert))
5338 .addDef(RegNo: InsertReg)
5339 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: V))
5340 .addUse(RegNo: ResVReg)
5341 .addUse(RegNo: Tmp)
5342 .addImm(Val: 0)
5343 .constrainAllUses(TII, TRI, RBI);
5344 Extract.substituteRegister(FromReg: ResVReg, ToReg: InsertReg, SubIdx: 0, RegInfo: TRI);
5345 }
5346 }
5347 return true;
5348}
5349
5350// Maybe wrap a value into OpSpecConstantOp
5351bool SPIRVInstructionSelector::wrapIntoSpecConstantOp(
5352 MachineInstr &I, SmallVector<Register> &CompositeArgs) const {
5353 unsigned Lim = I.getNumExplicitOperands();
5354 for (unsigned i = I.getNumExplicitDefs() + 1; i < Lim; ++i) {
5355 Register OpReg = I.getOperand(i).getReg();
5356 MachineInstr *OpDefine = MRI->getVRegDef(Reg: OpReg);
5357 SPIRVTypeInst OpType = GR.getSPIRVTypeForVReg(VReg: OpReg);
5358 if (!OpDefine || !OpType || isConstReg(MRI, OpDef: OpDefine) ||
5359 OpDefine->getOpcode() == TargetOpcode::G_ADDRSPACE_CAST ||
5360 OpDefine->getOpcode() == TargetOpcode::G_INTTOPTR ||
5361 GR.isAggregateType(Type: OpType)) {
5362 // The case of G_ADDRSPACE_CAST inside spv_const_composite() is processed
5363 // by selectAddrSpaceCast(), and G_INTTOPTR is processed by selectUnOp()
5364 CompositeArgs.push_back(Elt: OpReg);
5365 continue;
5366 }
5367 MachineFunction *MF = I.getMF();
5368 Register WrapReg = GR.find(MI: OpDefine, MF);
5369 if (WrapReg.isValid()) {
5370 CompositeArgs.push_back(Elt: WrapReg);
5371 continue;
5372 }
5373 SPIRVTypeInst WrapType = OpType;
5374 if (OpType->getOpcode() == SPIRV::OpTypePointer &&
5375 GR.getPointerStorageClass(Type: OpType) ==
5376 SPIRV::StorageClass::CodeSectionINTEL) {
5377 WrapType = GR.changePointerStorageClass(PtrType: OpType,
5378 SC: SPIRV::StorageClass::Function, I);
5379 }
5380 WrapReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: WrapType));
5381 CompositeArgs.push_back(Elt: WrapReg);
5382 // Decorate the wrapper register and generate a new instruction
5383 MRI->setType(VReg: WrapReg, Ty: LLT::pointer(AddressSpace: 0, SizeInBits: 64));
5384 GR.assignSPIRVTypeToVReg(Type: WrapType, VReg: WrapReg, MF: *MF);
5385 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
5386 MCID: TII.get(Opcode: SPIRV::OpSpecConstantOp))
5387 .addDef(RegNo: WrapReg)
5388 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: WrapType))
5389 .addImm(Val: static_cast<uint32_t>(SPIRV::Opcode::Bitcast))
5390 .addUse(RegNo: OpReg);
5391 GR.add(Obj: OpDefine, MI: MIB);
5392 MIB.constrainAllUses(TII, TRI, RBI);
5393 }
5394 return true;
5395}
5396
5397bool SPIRVInstructionSelector::selectDerivativeInst(
5398 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
5399 const unsigned DPdOpCode) const {
5400 // TODO: This should check specifically for Fragment Execution Model, but STI
5401 // doesn't provide that information yet. See #167562
5402 if (!errorIfInstrOutsideShader(I))
5403 return false;
5404
5405 // If the arg/result types are half then we need to wrap the instr in
5406 // conversions to float
5407 // This case occurs because a half arg/result is legal in HLSL but not spirv.
5408 Register SrcReg = I.getOperand(i: 2).getReg();
5409 SPIRVTypeInst SrcType = GR.getSPIRVTypeForVReg(VReg: SrcReg);
5410 unsigned BitWidth = std::min(a: GR.getScalarOrVectorBitWidth(Type: SrcType),
5411 b: GR.getScalarOrVectorBitWidth(Type: ResType));
5412 if (BitWidth == 32)
5413 return BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: DPdOpCode))
5414 .addDef(RegNo: ResVReg)
5415 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5416 .addUse(RegNo: I.getOperand(i: 2).getReg());
5417
5418 MachineIRBuilder MIRBuilder(I);
5419 unsigned componentCount = GR.getScalarOrVectorComponentCount(Type: SrcType);
5420 SPIRVTypeInst F32ConvertTy = GR.getOrCreateSPIRVFloatType(BitWidth: 32, I, TII);
5421 if (componentCount != 1)
5422 F32ConvertTy = GR.getOrCreateSPIRVVectorType(BaseType: F32ConvertTy, NumElements: componentCount,
5423 MIRBuilder, EmitIR: false);
5424
5425 const TargetRegisterClass *RegClass = GR.getRegClass(SpvType: SrcType);
5426 Register ConvertToVReg = MRI->createVirtualRegister(RegClass);
5427 Register DpdOpVReg = MRI->createVirtualRegister(RegClass);
5428
5429 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpFConvert))
5430 .addDef(RegNo: ConvertToVReg)
5431 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: F32ConvertTy))
5432 .addUse(RegNo: SrcReg)
5433 .constrainAllUses(TII, TRI, RBI);
5434 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: DPdOpCode))
5435 .addDef(RegNo: DpdOpVReg)
5436 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: F32ConvertTy))
5437 .addUse(RegNo: ConvertToVReg)
5438 .constrainAllUses(TII, TRI, RBI);
5439 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpFConvert))
5440 .addDef(RegNo: ResVReg)
5441 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5442 .addUse(RegNo: DpdOpVReg)
5443 .constrainAllUses(TII, TRI, RBI);
5444 return true;
5445}
5446
5447bool SPIRVInstructionSelector::selectIntrinsic(Register ResVReg,
5448 SPIRVTypeInst ResType,
5449 MachineInstr &I) const {
5450 MachineBasicBlock &BB = *I.getParent();
5451 Intrinsic::ID IID = cast<GIntrinsic>(Val&: I).getIntrinsicID();
5452 switch (IID) {
5453 case Intrinsic::spv_load:
5454 return selectLoad(ResVReg, ResType, I);
5455 case Intrinsic::spv_atomic_load:
5456 return selectAtomicLoad(ResVReg, ResType, I);
5457 case Intrinsic::spv_store:
5458 return selectStore(I);
5459 case Intrinsic::spv_atomic_store:
5460 return selectAtomicStore(I);
5461 case Intrinsic::spv_extractv:
5462 return selectExtractVal(ResVReg, ResType, I);
5463 case Intrinsic::spv_insertv:
5464 return selectInsertVal(ResVReg, ResType, I);
5465 case Intrinsic::spv_extractelt:
5466 return selectExtractElt(ResVReg, ResType, I);
5467 case Intrinsic::spv_insertelt:
5468 return selectInsertElt(ResVReg, ResType, I);
5469 case Intrinsic::spv_gep:
5470 return selectGEP(ResVReg, ResType, I);
5471 case Intrinsic::spv_bitcast: {
5472 Register OpReg = I.getOperand(i: 2).getReg();
5473 SPIRVTypeInst OpType =
5474 OpReg.isValid() ? GR.getSPIRVTypeForVReg(VReg: OpReg) : nullptr;
5475 if (!GR.isBitcastCompatible(Type1: ResType, Type2: OpType))
5476 report_fatal_error(reason: "incompatible result and operand types in a bitcast");
5477 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {OpReg}, Opcode: SPIRV::OpBitcast);
5478 }
5479 case Intrinsic::spv_unref_global:
5480 case Intrinsic::spv_init_global: {
5481 MachineInstr *MI = MRI->getVRegDef(Reg: I.getOperand(i: 1).getReg());
5482 MachineInstr *Init = I.getNumExplicitOperands() > 2
5483 ? MRI->getVRegDef(Reg: I.getOperand(i: 2).getReg())
5484 : nullptr;
5485 assert(MI);
5486 Register GVarVReg = MI->getOperand(i: 0).getReg();
5487 if (!selectGlobalValue(ResVReg: GVarVReg, I&: *MI, Init))
5488 return false;
5489 // We violate SSA form by inserting OpVariable and still having a gMIR
5490 // instruction %vreg = G_GLOBAL_VALUE @gvar. We need to fix this by erasing
5491 // the duplicated definition.
5492 if (MI->getOpcode() == TargetOpcode::G_GLOBAL_VALUE) {
5493 GR.invalidateMachineInstr(MI);
5494 MI->eraseFromParent();
5495 }
5496 return true;
5497 }
5498 case Intrinsic::spv_undef: {
5499 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUndef))
5500 .addDef(RegNo: ResVReg)
5501 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
5502 MIB.constrainAllUses(TII, TRI, RBI);
5503 return true;
5504 }
5505 case Intrinsic::spv_poison:
5506 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpPoisonKHR))
5507 .addDef(RegNo: ResVReg)
5508 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5509 .constrainAllUses(TII, TRI, RBI);
5510 return true;
5511 case Intrinsic::spv_freeze:
5512 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpFreezeKHR))
5513 .addDef(RegNo: ResVReg)
5514 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5515 .addUse(RegNo: I.getOperand(i: 2).getReg())
5516 .constrainAllUses(TII, TRI, RBI);
5517 return true;
5518 case Intrinsic::spv_named_boolean_spec_constant: {
5519 auto Opcode = I.getOperand(i: 3).getImm() ? SPIRV::OpSpecConstantTrue
5520 : SPIRV::OpSpecConstantFalse;
5521
5522 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
5523 .addDef(RegNo: I.getOperand(i: 0).getReg())
5524 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
5525 MIB.constrainAllUses(TII, TRI, RBI);
5526 unsigned SpecId = I.getOperand(i: 2).getImm();
5527 buildOpDecorate(Reg: I.getOperand(i: 0).getReg(), I&: *++MIB->getIterator(), TII,
5528 Dec: SPIRV::Decoration::SpecId, DecArgs: {SpecId});
5529
5530 return true;
5531 }
5532 case Intrinsic::spv_const_composite: {
5533 // If no values are attached, the composite is null constant.
5534 bool IsNull = I.getNumExplicitDefs() + 1 == I.getNumExplicitOperands();
5535 SmallVector<Register> CompositeArgs;
5536 MRI->setRegClass(Reg: ResVReg, RC: GR.getRegClass(SpvType: ResType));
5537
5538 // skip type MD node we already used when generated assign.type for this
5539 if (!IsNull) {
5540 if (!wrapIntoSpecConstantOp(I, CompositeArgs))
5541 return false;
5542 std::function<bool(Register)> HasSpecConstOperand =
5543 [&](Register Reg) -> bool {
5544 MachineInstr *Def = MRI->getVRegDef(Reg);
5545 if (!Def)
5546 return false;
5547 if (!isConstReg(MRI, OpDef: Def))
5548 return true;
5549 // Recurse into not-yet-selected spv_const_composite intrinsics
5550 // to detect transitive spec constant operands.
5551 if (isSpvIntrinsic(MI: *Def, IntrinsicID: Intrinsic::spv_const_composite)) {
5552 for (unsigned J = Def->getNumExplicitDefs() + 1;
5553 J < Def->getNumExplicitOperands(); ++J) {
5554 if (Def->getOperand(i: J).isReg() &&
5555 HasSpecConstOperand(Def->getOperand(i: J).getReg()))
5556 return true;
5557 }
5558 }
5559 return false;
5560 };
5561 bool HasSpecConst = llvm::any_of(Range&: CompositeArgs, P: HasSpecConstOperand);
5562 unsigned CompositeOpc = HasSpecConst ? SPIRV::OpSpecConstantComposite
5563 : SPIRV::OpConstantComposite;
5564 unsigned ContinuedOpc = HasSpecConst
5565 ? SPIRV::OpSpecConstantCompositeContinuedINTEL
5566 : SPIRV::OpConstantCompositeContinuedINTEL;
5567 MachineIRBuilder MIR(I);
5568 SmallVector<MachineInstr *, 4> Instructions = createContinuedInstructions(
5569 MIRBuilder&: MIR, Opcode: CompositeOpc, MinWC: 3, ContinuedOpcode: ContinuedOpc, Args: CompositeArgs, ReturnRegister: ResVReg,
5570 TypeID: GR.getSPIRVTypeID(SpirvType: ResType));
5571 for (auto *Instr : Instructions) {
5572 Instr->setDebugLoc(I.getDebugLoc());
5573 constrainSelectedInstRegOperands(I&: *Instr, TII, TRI, RBI);
5574 }
5575 return true;
5576 } else {
5577 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpConstantNull))
5578 .addDef(RegNo: ResVReg)
5579 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
5580 MIB.constrainAllUses(TII, TRI, RBI);
5581 return true;
5582 }
5583 }
5584 case Intrinsic::spv_assign_name: {
5585 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpName));
5586 MIB.addUse(RegNo: I.getOperand(i: I.getNumExplicitDefs() + 1).getReg());
5587 for (unsigned i = I.getNumExplicitDefs() + 2;
5588 i < I.getNumExplicitOperands(); ++i) {
5589 MIB.addImm(Val: I.getOperand(i).getImm());
5590 }
5591 MIB.constrainAllUses(TII, TRI, RBI);
5592 return true;
5593 }
5594 case Intrinsic::spv_switch: {
5595 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSwitch));
5596 for (unsigned i = 1; i < I.getNumExplicitOperands(); ++i) {
5597 if (I.getOperand(i).isReg())
5598 MIB.addReg(RegNo: I.getOperand(i).getReg());
5599 else if (I.getOperand(i).isCImm())
5600 addNumImm(Imm: I.getOperand(i).getCImm()->getValue(), MIB);
5601 else if (I.getOperand(i).isMBB())
5602 MIB.addMBB(MBB: I.getOperand(i).getMBB());
5603 else
5604 llvm_unreachable("Unexpected OpSwitch operand");
5605 }
5606 MIB.constrainAllUses(TII, TRI, RBI);
5607 return true;
5608 }
5609 case Intrinsic::spv_loop_merge: {
5610 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoopMerge));
5611 for (unsigned i = 1; i < I.getNumExplicitOperands(); ++i) {
5612 if (I.getOperand(i).isMBB())
5613 MIB.addMBB(MBB: I.getOperand(i).getMBB());
5614 else
5615 MIB.addImm(Val: foldImm(MO: I.getOperand(i), MRI));
5616 }
5617 MIB.constrainAllUses(TII, TRI, RBI);
5618 return true;
5619 }
5620 case Intrinsic::spv_loop_control_intel: {
5621 auto MIB =
5622 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoopControlINTEL));
5623 for (unsigned J = 1; J < I.getNumExplicitOperands(); ++J)
5624 MIB.addImm(Val: foldImm(MO: I.getOperand(i: J), MRI));
5625 MIB.constrainAllUses(TII, TRI, RBI);
5626 return true;
5627 }
5628 case Intrinsic::spv_selection_merge: {
5629 auto MIB =
5630 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSelectionMerge));
5631 assert(I.getOperand(1).isMBB() &&
5632 "operand 1 to spv_selection_merge must be a basic block");
5633 MIB.addMBB(MBB: I.getOperand(i: 1).getMBB());
5634 MIB.addImm(Val: getSelectionOperandForImm(Imm: I.getOperand(i: 2).getImm()));
5635 MIB.constrainAllUses(TII, TRI, RBI);
5636 return true;
5637 }
5638 case Intrinsic::spv_cmpxchg:
5639 return selectAtomicCmpXchg(ResVReg, ResType, I);
5640 case Intrinsic::spv_unreachable:
5641 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUnreachable))
5642 .constrainAllUses(TII, TRI, RBI);
5643 return true;
5644 case Intrinsic::spv_abort:
5645 return selectAbort(I);
5646 case Intrinsic::spv_alloca:
5647 return selectFrameIndex(ResVReg, ResType, I);
5648 case Intrinsic::spv_alloca_array:
5649 return selectAllocaArray(ResVReg, ResType, I);
5650 case Intrinsic::spv_assume:
5651 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_expect_assume)) {
5652 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAssumeTrueKHR))
5653 .addUse(RegNo: I.getOperand(i: 1).getReg())
5654 .constrainAllUses(TII, TRI, RBI);
5655 return true;
5656 }
5657 break;
5658 case Intrinsic::spv_expect:
5659 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_expect_assume)) {
5660 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExpectKHR))
5661 .addDef(RegNo: ResVReg)
5662 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5663 .addUse(RegNo: I.getOperand(i: 2).getReg())
5664 .addUse(RegNo: I.getOperand(i: 3).getReg())
5665 .constrainAllUses(TII, TRI, RBI);
5666 return true;
5667 }
5668 break;
5669 case Intrinsic::arithmetic_fence:
5670 if (STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_arithmetic_fence)) {
5671 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpArithmeticFenceEXT))
5672 .addDef(RegNo: ResVReg)
5673 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5674 .addUse(RegNo: I.getOperand(i: 2).getReg())
5675 .constrainAllUses(TII, TRI, RBI);
5676 return true;
5677 } else
5678 return BuildCOPY(DestReg: ResVReg, SrcReg: I.getOperand(i: 2).getReg(), I);
5679 break;
5680 case Intrinsic::spv_thread_id:
5681 // The HLSL SV_DispatchThreadID semantic is lowered to llvm.spv.thread.id
5682 // intrinsic in LLVM IR for SPIR-V backend.
5683 //
5684 // In SPIR-V backend, llvm.spv.thread.id is now correctly translated to a
5685 // `GlobalInvocationId` builtin variable
5686 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::GlobalInvocationId, ResVReg,
5687 ResType, I);
5688 case Intrinsic::spv_thread_id_in_group:
5689 // The HLSL SV_GroupThreadId semantic is lowered to
5690 // llvm.spv.thread.id.in.group intrinsic in LLVM IR for SPIR-V backend.
5691 //
5692 // In SPIR-V backend, llvm.spv.thread.id.in.group is now correctly
5693 // translated to a `LocalInvocationId` builtin variable
5694 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::LocalInvocationId, ResVReg,
5695 ResType, I);
5696 case Intrinsic::spv_group_id:
5697 // The HLSL SV_GroupId semantic is lowered to
5698 // llvm.spv.group.id intrinsic in LLVM IR for SPIR-V backend.
5699 //
5700 // In SPIR-V backend, llvm.spv.group.id is now translated to a `WorkgroupId`
5701 // builtin variable
5702 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::WorkgroupId, ResVReg, ResType,
5703 I);
5704 case Intrinsic::spv_flattened_thread_id_in_group:
5705 // The HLSL SV_GroupIndex semantic is lowered to
5706 // llvm.spv.flattened.thread.id.in.group() intrinsic in LLVM IR for SPIR-V
5707 // backend.
5708 //
5709 // In SPIR-V backend, llvm.spv.flattened.thread.id.in.group is translated to
5710 // a `LocalInvocationIndex` builtin variable
5711 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::LocalInvocationIndex, ResVReg,
5712 ResType, I);
5713 case Intrinsic::spv_workgroup_size:
5714 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::WorkgroupSize, ResVReg,
5715 ResType, I);
5716 case Intrinsic::spv_global_size:
5717 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::GlobalSize, ResVReg, ResType,
5718 I);
5719 case Intrinsic::spv_global_offset:
5720 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::GlobalOffset, ResVReg,
5721 ResType, I);
5722 case Intrinsic::spv_num_workgroups:
5723 return loadVec3BuiltinInputID(BuiltInValue: SPIRV::BuiltIn::NumWorkgroups, ResVReg,
5724 ResType, I);
5725 case Intrinsic::spv_subgroup_size:
5726 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::SubgroupSize, ResVReg, ResType,
5727 I);
5728 case Intrinsic::spv_num_subgroups:
5729 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::NumSubgroups, ResVReg, ResType,
5730 I);
5731 case Intrinsic::spv_subgroup_id:
5732 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::SubgroupId, ResVReg, ResType, I);
5733 case Intrinsic::spv_subgroup_local_invocation_id:
5734 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::SubgroupLocalInvocationId,
5735 ResVReg, ResType, I);
5736 case Intrinsic::spv_subgroup_max_size:
5737 return loadBuiltinInputID(BuiltInValue: SPIRV::BuiltIn::SubgroupMaxSize, ResVReg, ResType,
5738 I);
5739 case Intrinsic::spv_fdot:
5740 return selectFloatDot(ResVReg, ResType, I);
5741 case Intrinsic::spv_udot:
5742 case Intrinsic::spv_sdot:
5743 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_integer_dot_product) ||
5744 STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 6)))
5745 return selectIntegerDot(ResVReg, ResType, I,
5746 /*Signed=*/IID == Intrinsic::spv_sdot);
5747 return selectIntegerDotExpansion(ResVReg, ResType, I);
5748 case Intrinsic::spv_dot4add_i8packed:
5749 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_integer_dot_product) ||
5750 STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 6)))
5751 return selectDot4AddPacked<true>(ResVReg, ResType, I);
5752 return selectDot4AddPackedExpansion<true>(ResVReg, ResType, I);
5753 case Intrinsic::spv_dot4add_u8packed:
5754 if (STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_integer_dot_product) ||
5755 STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 6)))
5756 return selectDot4AddPacked<false>(ResVReg, ResType, I);
5757 return selectDot4AddPackedExpansion<false>(ResVReg, ResType, I);
5758 case Intrinsic::spv_all:
5759 return selectAll(ResVReg, ResType, I);
5760 case Intrinsic::spv_any:
5761 return selectAny(ResVReg, ResType, I);
5762 case Intrinsic::spv_distance:
5763 return selectExtInst(ResVReg, ResType, I, CLInst: CL::distance, GLInst: GL::Distance);
5764 case Intrinsic::spv_lerp:
5765 return selectExtInst(ResVReg, ResType, I, CLInst: CL::mix, GLInst: GL::FMix);
5766 case Intrinsic::spv_length:
5767 return selectExtInst(ResVReg, ResType, I, CLInst: CL::length, GLInst: GL::Length);
5768 case Intrinsic::spv_degrees:
5769 return selectExtInst(ResVReg, ResType, I, CLInst: CL::degrees, GLInst: GL::Degrees);
5770 case Intrinsic::spv_faceforward:
5771 return selectExtInst(ResVReg, ResType, I, GLInst: GL::FaceForward);
5772 case Intrinsic::spv_frac:
5773 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fract, GLInst: GL::Fract);
5774 case Intrinsic::spv_isinf:
5775 return selectOpIsInf(ResVReg, ResType, I);
5776 case Intrinsic::spv_isnan:
5777 return selectOpIsNan(ResVReg, ResType, I);
5778 case Intrinsic::spv_isfinite:
5779 return selectOpIsFinite(ResVReg, ResType, I);
5780 case Intrinsic::spv_isnormal:
5781 return selectOpIsNormal(ResVReg, ResType, I);
5782 case Intrinsic::spv_normalize:
5783 return selectExtInst(ResVReg, ResType, I, CLInst: CL::normalize, GLInst: GL::Normalize);
5784 case Intrinsic::spv_refract:
5785 return selectExtInst(ResVReg, ResType, I, GLInst: GL::Refract);
5786 case Intrinsic::spv_reflect:
5787 return selectExtInst(ResVReg, ResType, I, GLInst: GL::Reflect);
5788 case Intrinsic::spv_rsqrt:
5789 return selectExtInst(ResVReg, ResType, I, CLInst: CL::rsqrt, GLInst: GL::InverseSqrt);
5790 case Intrinsic::spv_sign:
5791 return selectSign(ResVReg, ResType, I);
5792 case Intrinsic::spv_smoothstep:
5793 return selectExtInst(ResVReg, ResType, I, CLInst: CL::smoothstep, GLInst: GL::SmoothStep);
5794 case Intrinsic::spv_firstbituhigh: // There is no CL equivalent of FindUMsb
5795 return selectFirstBitHigh(ResVReg, ResType, I, /*IsSigned=*/false);
5796 case Intrinsic::spv_firstbitshigh: // There is no CL equivalent of FindSMsb
5797 return selectFirstBitHigh(ResVReg, ResType, I, /*IsSigned=*/true);
5798 case Intrinsic::spv_firstbitlow: // There is no CL equivlent of FindILsb
5799 return selectFirstBitLow(ResVReg, ResType, I);
5800 case Intrinsic::spv_all_memory_barrier:
5801 return selectBarrierInst(I, Scope: SPIRV::Scope::Device,
5802 MemSem: SPIRV::MemorySemantics::UniformMemory |
5803 SPIRV::MemorySemantics::ImageMemory |
5804 SPIRV::MemorySemantics::WorkgroupMemory,
5805 /*WithGroupSync*/ false);
5806 case Intrinsic::spv_all_memory_barrier_with_group_sync:
5807 return selectBarrierInst(I, Scope: SPIRV::Scope::Device,
5808 MemSem: SPIRV::MemorySemantics::UniformMemory |
5809 SPIRV::MemorySemantics::ImageMemory |
5810 SPIRV::MemorySemantics::WorkgroupMemory,
5811 /*WithGroupSync*/ true);
5812 case Intrinsic::spv_device_memory_barrier:
5813 return selectBarrierInst(I, Scope: SPIRV::Scope::Device,
5814 MemSem: SPIRV::MemorySemantics::UniformMemory |
5815 SPIRV::MemorySemantics::ImageMemory,
5816 /*WithGroupSync*/ false);
5817 case Intrinsic::spv_device_memory_barrier_with_group_sync:
5818 return selectBarrierInst(I, Scope: SPIRV::Scope::Device,
5819 MemSem: SPIRV::MemorySemantics::UniformMemory |
5820 SPIRV::MemorySemantics::ImageMemory,
5821 /*WithGroupSync*/ true);
5822 case Intrinsic::spv_group_memory_barrier:
5823 return selectBarrierInst(I, Scope: SPIRV::Scope::Workgroup,
5824 MemSem: SPIRV::MemorySemantics::WorkgroupMemory,
5825 /*WithGroupSync*/ false);
5826 case Intrinsic::spv_group_memory_barrier_with_group_sync:
5827 return selectBarrierInst(I, Scope: SPIRV::Scope::Workgroup,
5828 MemSem: SPIRV::MemorySemantics::WorkgroupMemory,
5829 /*WithGroupSync*/ true);
5830 case Intrinsic::spv_generic_cast_to_ptr_explicit: {
5831 Register PtrReg = I.getOperand(i: I.getNumExplicitDefs() + 1).getReg();
5832 SPIRV::StorageClass::StorageClass ResSC =
5833 GR.getPointerStorageClass(Type: ResType);
5834 if (!isGenericCastablePtr(SC: ResSC))
5835 return diagnoseUnsupported(I, Msg: "The target storage class is not castable "
5836 "from the Generic storage class");
5837 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpGenericCastToPtrExplicit))
5838 .addDef(RegNo: ResVReg)
5839 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
5840 .addUse(RegNo: PtrReg)
5841 .addImm(Val: ResSC)
5842 .constrainAllUses(TII, TRI, RBI);
5843 return true;
5844 }
5845 case Intrinsic::spv_lifetime_start:
5846 case Intrinsic::spv_lifetime_end: {
5847 unsigned Op = IID == Intrinsic::spv_lifetime_start ? SPIRV::OpLifetimeStart
5848 : SPIRV::OpLifetimeStop;
5849 int64_t Size = I.getOperand(i: I.getNumExplicitDefs() + 1).getImm();
5850 Register PtrReg = I.getOperand(i: I.getNumExplicitDefs() + 2).getReg();
5851 if (Size == -1)
5852 Size = 0;
5853 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: Op))
5854 .addUse(RegNo: PtrReg)
5855 .addImm(Val: Size)
5856 .constrainAllUses(TII, TRI, RBI);
5857 return true;
5858 }
5859 case Intrinsic::spv_saturate:
5860 return selectSaturate(ResVReg, ResType, I);
5861 case Intrinsic::spv_nclamp:
5862 return selectExtInst(ResVReg, ResType, I, CLInst: CL::fclamp, GLInst: GL::NClamp);
5863 case Intrinsic::spv_uclamp:
5864 return selectExtInst(ResVReg, ResType, I, CLInst: CL::u_clamp, GLInst: GL::UClamp);
5865 case Intrinsic::spv_sclamp:
5866 return selectExtInst(ResVReg, ResType, I, CLInst: CL::s_clamp, GLInst: GL::SClamp);
5867 case Intrinsic::spv_subgroup_prefix_bit_count:
5868 return selectWavePrefixBitCount(ResVReg, ResType, I);
5869 case Intrinsic::spv_wave_active_countbits:
5870 return selectWaveActiveCountBits(ResVReg, ResType, I);
5871 case Intrinsic::spv_wave_all_equal:
5872 return selectWaveActiveAllEqual(ResVReg, ResType, I);
5873 case Intrinsic::spv_wave_all:
5874 return selectWaveOpInst(ResVReg, ResType, I, Opcode: SPIRV::OpGroupNonUniformAll);
5875 case Intrinsic::spv_wave_any:
5876 return selectWaveOpInst(ResVReg, ResType, I, Opcode: SPIRV::OpGroupNonUniformAny);
5877 case Intrinsic::spv_subgroup_ballot:
5878 return selectWaveOpInst(ResVReg, ResType, I,
5879 Opcode: SPIRV::OpGroupNonUniformBallot);
5880 case Intrinsic::spv_wave_is_first_lane:
5881 return selectWaveOpInst(ResVReg, ResType, I, Opcode: SPIRV::OpGroupNonUniformElect);
5882 case Intrinsic::spv_wave_reduce_or:
5883 return selectWaveReduceOp(ResVReg, ResType, I,
5884 Opcode: SPIRV::OpGroupNonUniformBitwiseOr);
5885 case Intrinsic::spv_wave_reduce_xor:
5886 return selectWaveReduceOp(ResVReg, ResType, I,
5887 Opcode: SPIRV::OpGroupNonUniformBitwiseXor);
5888 case Intrinsic::spv_wave_reduce_and:
5889 return selectWaveReduceOp(ResVReg, ResType, I,
5890 Opcode: SPIRV::OpGroupNonUniformBitwiseAnd);
5891 case Intrinsic::spv_wave_reduce_umax:
5892 return selectWaveReduceMax(ResVReg, ResType, I, /*IsUnsigned*/ true);
5893 case Intrinsic::spv_wave_reduce_max:
5894 return selectWaveReduceMax(ResVReg, ResType, I, /*IsUnsigned*/ false);
5895 case Intrinsic::spv_wave_reduce_umin:
5896 return selectWaveReduceMin(ResVReg, ResType, I, /*IsUnsigned*/ true);
5897 case Intrinsic::spv_wave_reduce_min:
5898 return selectWaveReduceMin(ResVReg, ResType, I, /*IsUnsigned*/ false);
5899 case Intrinsic::spv_wave_reduce_sum:
5900 return selectWaveReduceSum(ResVReg, ResType, I);
5901 case Intrinsic::spv_wave_product:
5902 return selectWaveReduceProduct(ResVReg, ResType, I);
5903 case Intrinsic::spv_wave_readlane:
5904 return selectWaveOpInst(ResVReg, ResType, I,
5905 Opcode: SPIRV::OpGroupNonUniformShuffle);
5906 case Intrinsic::spv_wave_readlane_first:
5907 return selectWaveOpInst(ResVReg, ResType, I,
5908 Opcode: SPIRV::OpGroupNonUniformBroadcastFirst);
5909 case Intrinsic::spv_wave_prefix_sum:
5910 return selectWaveExclusiveScanSum(ResVReg, ResType, I);
5911 case Intrinsic::spv_subgroup_multi_prefix_bit_and:
5912 return selectWaveMultiPrefixOp(ResVReg, ResType, I,
5913 Opcode: SPIRV::OpGroupNonUniformBitwiseAnd,
5914 BuiltinName: "WaveMultiPrefixBitAnd");
5915 case Intrinsic::spv_subgroup_multi_prefix_bit_or:
5916 return selectWaveMultiPrefixOp(ResVReg, ResType, I,
5917 Opcode: SPIRV::OpGroupNonUniformBitwiseOr,
5918 BuiltinName: "WaveMultiPrefixBitOr");
5919 case Intrinsic::spv_subgroup_multi_prefix_bit_xor:
5920 return selectWaveMultiPrefixOp(ResVReg, ResType, I,
5921 Opcode: SPIRV::OpGroupNonUniformBitwiseXor,
5922 BuiltinName: "WaveMultiPrefixBitXor");
5923 case Intrinsic::spv_subgroup_multi_prefix_product: {
5924 bool IsFloatTy =
5925 GR.isScalarOrVectorOfType(VReg: I.getOperand(i: 2).getReg(), TypeOpcode: SPIRV::OpTypeFloat);
5926 return selectWaveMultiPrefixOp(ResVReg, ResType, I,
5927 Opcode: IsFloatTy ? SPIRV::OpGroupNonUniformFMul
5928 : SPIRV::OpGroupNonUniformIMul,
5929 BuiltinName: "WaveMultiPrefixProduct");
5930 }
5931 case Intrinsic::spv_subgroup_multi_prefix_sum: {
5932 bool IsFloatTy =
5933 GR.isScalarOrVectorOfType(VReg: I.getOperand(i: 2).getReg(), TypeOpcode: SPIRV::OpTypeFloat);
5934 return selectWaveMultiPrefixOp(ResVReg, ResType, I,
5935 Opcode: IsFloatTy ? SPIRV::OpGroupNonUniformFAdd
5936 : SPIRV::OpGroupNonUniformIAdd,
5937 BuiltinName: "WaveMultiPrefixSum");
5938 }
5939 case Intrinsic::spv_wave_prefix_product:
5940 return selectWaveExclusiveScanProduct(ResVReg, ResType, I);
5941 case Intrinsic::spv_quad_all:
5942 return selectQuadAll(ResVReg, ResType, I);
5943 case Intrinsic::spv_quad_read_across_x: {
5944 return selectQuadSwap(ResVReg, ResType, I, /*Direction*/ 0);
5945 }
5946 case Intrinsic::spv_quad_read_across_y: {
5947 return selectQuadSwap(ResVReg, ResType, I, /*Direction*/ 1);
5948 }
5949 case Intrinsic::spv_quad_read_across_diagonal: {
5950 return selectQuadSwap(ResVReg, ResType, I, /*Direction*/ 2);
5951 }
5952 case Intrinsic::spv_radians:
5953 return selectExtInst(ResVReg, ResType, I, CLInst: CL::radians, GLInst: GL::Radians);
5954 // Discard intrinsics which we do not expect to actually represent code after
5955 // lowering or intrinsics which are not implemented but should not crash when
5956 // found in a customer's LLVM IR input.
5957 case Intrinsic::instrprof_increment:
5958 case Intrinsic::instrprof_increment_step:
5959 case Intrinsic::instrprof_value_profile:
5960 break;
5961 // Discard internal intrinsics.
5962 case Intrinsic::spv_value_md:
5963 break;
5964 case Intrinsic::spv_resource_handlefrombinding: {
5965 return selectHandleFromBinding(ResVReg, ResType, I);
5966 }
5967 case Intrinsic::spv_resource_counterhandlefrombinding:
5968 return selectCounterHandleFromBinding(ResVReg, ResType, I);
5969 case Intrinsic::spv_resource_updatecounter:
5970 return selectUpdateCounter(ResVReg, ResType, I);
5971 case Intrinsic::spv_resource_store_typedbuffer: {
5972 return selectImageWriteIntrinsic(I);
5973 }
5974 case Intrinsic::spv_resource_load_typedbuffer: {
5975 return selectReadImageIntrinsic(ResVReg, ResType, I);
5976 }
5977 case Intrinsic::spv_resource_load_level: {
5978 return selectLoadLevelIntrinsic(ResVReg, ResType, I);
5979 }
5980 case Intrinsic::spv_resource_getdimensions_x:
5981 case Intrinsic::spv_resource_getdimensions_xy:
5982 case Intrinsic::spv_resource_getdimensions_xyz: {
5983 return selectGetDimensionsIntrinsic(ResVReg, ResType, I);
5984 }
5985 case Intrinsic::spv_resource_getdimensions_levels_x:
5986 case Intrinsic::spv_resource_getdimensions_levels_xy:
5987 case Intrinsic::spv_resource_getdimensions_levels_xyz: {
5988 return selectGetDimensionsLevelsIntrinsic(ResVReg, ResType, I);
5989 }
5990 case Intrinsic::spv_resource_getdimensions_ms_xy:
5991 case Intrinsic::spv_resource_getdimensions_ms_xyz: {
5992 return selectGetDimensionsMSIntrinsic(ResVReg, ResType, I);
5993 }
5994 case Intrinsic::spv_resource_calculate_lod:
5995 case Intrinsic::spv_resource_calculate_lod_unclamped:
5996 return selectCalculateLodIntrinsic(ResVReg, ResType, I);
5997 case Intrinsic::spv_resource_sample:
5998 case Intrinsic::spv_resource_sample_clamp:
5999 return selectSampleBasicIntrinsic(ResVReg, ResType, I);
6000 case Intrinsic::spv_resource_samplebias:
6001 case Intrinsic::spv_resource_samplebias_clamp:
6002 return selectSampleBiasIntrinsic(ResVReg, ResType, I);
6003 case Intrinsic::spv_resource_samplegrad:
6004 case Intrinsic::spv_resource_samplegrad_clamp:
6005 return selectSampleGradIntrinsic(ResVReg, ResType, I);
6006 case Intrinsic::spv_resource_samplelevel:
6007 return selectSampleLevelIntrinsic(ResVReg, ResType, I);
6008 case Intrinsic::spv_resource_samplecmp:
6009 case Intrinsic::spv_resource_samplecmp_clamp:
6010 return selectSampleCmpIntrinsic(ResVReg, ResType, I);
6011 case Intrinsic::spv_resource_samplecmplevelzero:
6012 return selectSampleCmpLevelZeroIntrinsic(ResVReg, ResType, I);
6013 case Intrinsic::spv_resource_gather:
6014 case Intrinsic::spv_resource_gather_cmp:
6015 return selectGatherIntrinsic(ResVReg, ResType, I);
6016 case Intrinsic::spv_resource_getbasepointer:
6017 case Intrinsic::spv_resource_getpointer: {
6018 return selectResourceGetPointer(ResVReg, ResType, I);
6019 }
6020 case Intrinsic::spv_pushconstant_getpointer: {
6021 return selectPushConstantGetPointer(ResVReg, ResType, I);
6022 }
6023 case Intrinsic::spv_discard: {
6024 return selectDiscard(ResVReg, ResType, I);
6025 }
6026 case Intrinsic::spv_resource_nonuniformindex: {
6027 return selectResourceNonUniformIndex(ResVReg, ResType, I);
6028 }
6029 case Intrinsic::spv_unpackhalf2x16: {
6030 return selectExtInst(ResVReg, ResType, I, GLInst: GL::UnpackHalf2x16);
6031 }
6032 case Intrinsic::spv_packhalf2x16: {
6033 return selectExtInst(ResVReg, ResType, I, GLInst: GL::PackHalf2x16);
6034 }
6035 case Intrinsic::spv_ddx:
6036 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdx);
6037 case Intrinsic::spv_ddy:
6038 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdy);
6039 case Intrinsic::spv_ddx_coarse:
6040 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdxCoarse);
6041 case Intrinsic::spv_ddy_coarse:
6042 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdyCoarse);
6043 case Intrinsic::spv_ddx_fine:
6044 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdxFine);
6045 case Intrinsic::spv_ddy_fine:
6046 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpDPdyFine);
6047 case Intrinsic::spv_fwidth:
6048 return selectDerivativeInst(ResVReg, ResType, I, DPdOpCode: SPIRV::OpFwidth);
6049 case Intrinsic::spv_masked_gather:
6050 if (STI.canUseExtension(E: SPIRV::Extension::SPV_INTEL_masked_gather_scatter))
6051 return selectMaskedGather(ResVReg, ResType, I);
6052 return diagnoseUnsupported(
6053 I, Msg: "llvm.masked.gather requires SPV_INTEL_masked_gather_scatter");
6054 case Intrinsic::spv_masked_scatter:
6055 if (STI.canUseExtension(E: SPIRV::Extension::SPV_INTEL_masked_gather_scatter))
6056 return selectMaskedScatter(I);
6057 return diagnoseUnsupported(
6058 I, Msg: "llvm.masked.scatter requires SPV_INTEL_masked_gather_scatter");
6059 case Intrinsic::returnaddress:
6060 case Intrinsic::frameaddress: {
6061 // SPIR-V does not have a stack or return address. Lower to null.
6062 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpConstantNull))
6063 .addDef(RegNo: ResVReg)
6064 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
6065 MIB.constrainAllUses(TII, TRI, RBI);
6066 return true;
6067 }
6068 default:
6069 return diagnoseUnsupported(I, Msg: "intrinsic selection not implemented.");
6070 }
6071 return true;
6072}
6073
6074bool SPIRVInstructionSelector::selectHandleFromBinding(Register &ResVReg,
6075 SPIRVTypeInst ResType,
6076 MachineInstr &I) const {
6077 // Image users reload the handle, so this load serves only other users.
6078 return loadHandleBeforePosition(HandleReg&: ResVReg, ResType, HandleDef&: *cast<GIntrinsic>(Val: &I), Pos&: I);
6079}
6080
6081bool SPIRVInstructionSelector::selectCounterHandleFromBinding(
6082 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6083 auto &Intr = cast<GIntrinsic>(Val&: I);
6084 assert(Intr.getIntrinsicID() ==
6085 Intrinsic::spv_resource_counterhandlefrombinding);
6086
6087 // Extract information from the intrinsic call.
6088 Register MainHandleReg = Intr.getOperand(i: 2).getReg();
6089 auto *MainHandleDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: MainHandleReg));
6090 assert(MainHandleDef->getIntrinsicID() ==
6091 Intrinsic::spv_resource_handlefrombinding);
6092
6093 uint32_t Set = getIConstVal(ConstReg: Intr.getOperand(i: 3).getReg(), MRI);
6094 uint32_t Binding = getIConstVal(ConstReg: Intr.getOperand(i: 4).getReg(), MRI);
6095 uint32_t ArraySize = getIConstVal(ConstReg: MainHandleDef->getOperand(i: 4).getReg(), MRI);
6096 Register IndexReg = MainHandleDef->getOperand(i: 5).getReg();
6097 std::string CounterName =
6098 getStringValueFromReg(Reg: MainHandleDef->getOperand(i: 6).getReg(), MRI&: *MRI) +
6099 ".counter";
6100
6101 // Create the counter variable.
6102 MachineIRBuilder MIRBuilder(I);
6103 Register CounterVarReg =
6104 buildPointerToResource(ResType: SPIRVTypeInst(GR.getPointeeType(PtrType: ResType)),
6105 SC: GR.getPointerStorageClass(Type: ResType), Set, Binding,
6106 ArraySize, IndexReg, Name: CounterName, MIRBuilder);
6107
6108 return BuildCOPY(DestReg: ResVReg, SrcReg: CounterVarReg, I);
6109}
6110
6111bool SPIRVInstructionSelector::selectUpdateCounter(Register &ResVReg,
6112 SPIRVTypeInst ResType,
6113 MachineInstr &I) const {
6114 auto &Intr = cast<GIntrinsic>(Val&: I);
6115 assert(Intr.getIntrinsicID() == Intrinsic::spv_resource_updatecounter);
6116
6117 Register CounterHandleReg = Intr.getOperand(i: 2).getReg();
6118 int64_t IncrVal = Intr.getOperand(i: 3).getImm();
6119
6120 // The counter handle is a pointer to the counter variable (which is a struct
6121 // containing an i32). We need to get a pointer to that i32 member to do the
6122 // atomic operation.
6123#ifndef NDEBUG
6124 SPIRVTypeInst CounterVarType = GR.getSPIRVTypeForVReg(CounterHandleReg);
6125 SPIRVTypeInst CounterVarPointeeType = GR.getPointeeType(CounterVarType);
6126 assert(CounterVarPointeeType &&
6127 CounterVarPointeeType->getOpcode() == SPIRV::OpTypeStruct &&
6128 "Counter variable must be a struct");
6129 assert(GR.getPointerStorageClass(CounterVarType) ==
6130 SPIRV::StorageClass::StorageBuffer &&
6131 "Counter variable must be in the storage buffer storage class");
6132 assert(CounterVarPointeeType->getNumOperands() == 2 &&
6133 "Counter variable must have exactly 1 member in the struct");
6134 const SPIRVTypeInst MemberType =
6135 GR.getSPIRVTypeForVReg(CounterVarPointeeType->getOperand(1).getReg());
6136 assert(MemberType->getOpcode() == SPIRV::OpTypeInt &&
6137 "Counter variable struct must have a single i32 member");
6138#endif
6139
6140 // The struct has a single i32 member.
6141 MachineIRBuilder MIRBuilder(I);
6142 const Type *LLVMIntType =
6143 Type::getInt32Ty(C&: I.getMF()->getFunction().getContext());
6144
6145 SPIRVTypeInst IntPtrType = GR.getOrCreateSPIRVPointerType(
6146 BaseType: LLVMIntType, MIRBuilder, SC: SPIRV::StorageClass::StorageBuffer);
6147
6148 Register Zero = buildI32ConstantInEntryBlock(Val: 0, I);
6149
6150 Register PtrToCounter =
6151 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: IntPtrType));
6152 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAccessChain))
6153 .addDef(RegNo: PtrToCounter)
6154 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: IntPtrType))
6155 .addUse(RegNo: CounterHandleReg)
6156 .addUse(RegNo: Zero)
6157 .constrainAllUses(TII, TRI, RBI);
6158
6159 // For UAV/SSBO counters, the scope is Device. The counter variable is not
6160 // used as a flag. So the memory semantics can be None.
6161 Register Scope = buildI32ConstantInEntryBlock(Val: SPIRV::Scope::Device, I);
6162 Register Semantics =
6163 buildI32ConstantInEntryBlock(Val: SPIRV::MemorySemantics::None, I);
6164
6165 Register Incr =
6166 buildI32ConstantInEntryBlock(Val: static_cast<uint32_t>(IncrVal), I);
6167
6168 Register AtomicRes = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
6169 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAtomicIAdd))
6170 .addDef(RegNo: AtomicRes)
6171 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6172 .addUse(RegNo: PtrToCounter)
6173 .addUse(RegNo: Scope)
6174 .addUse(RegNo: Semantics)
6175 .addUse(RegNo: Incr)
6176 .constrainAllUses(TII, TRI, RBI);
6177 if (IncrVal >= 0) {
6178 return BuildCOPY(DestReg: ResVReg, SrcReg: AtomicRes, I);
6179 }
6180
6181 // In HLSL, IncrementCounter returns the value *before* the increment, while
6182 // DecrementCounter returns the value *after* the decrement. Both are lowered
6183 // to the same atomic intrinsic which returns the value *before* the
6184 // operation. So for decrements (negative IncrVal), we must subtract the
6185 // increment value from the result to get the post-decrement value.
6186 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpIAddS))
6187 .addDef(RegNo: ResVReg)
6188 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6189 .addUse(RegNo: AtomicRes)
6190 .addUse(RegNo: Incr)
6191 .constrainAllUses(TII, TRI, RBI);
6192 return true;
6193}
6194bool SPIRVInstructionSelector::selectReadImageIntrinsic(Register &ResVReg,
6195 SPIRVTypeInst ResType,
6196 MachineInstr &I) const {
6197
6198 // If the load of the image is in a different basic block, then
6199 // this will generate invalid code. A proper solution is to move
6200 // the OpLoad from selectHandleFromBinding here. However, to do
6201 // that we will need to change the return type of the intrinsic.
6202 // We will do that when we can, but for now trying to move forward with other
6203 // issues.
6204 Register ImageReg = I.getOperand(i: 2).getReg();
6205 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6206 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6207 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6208 HandleDef&: *ImageDef, Pos&: I)) {
6209 return false;
6210 }
6211
6212 Register IdxReg = I.getOperand(i: 3).getReg();
6213 DebugLoc Loc = I.getDebugLoc();
6214 MachineInstr &Pos = I;
6215
6216 return generateImageReadOrFetch(ResVReg, ResType, ImageReg: NewImageReg, IdxReg, Loc,
6217 Pos);
6218}
6219
6220bool SPIRVInstructionSelector::generateSampleImage(
6221 Register ResVReg, SPIRVTypeInst ResType, Register ImageReg,
6222 Register SamplerReg, Register CoordinateReg, const ImageOperands &ImOps,
6223 DebugLoc Loc, MachineInstr &Pos) const {
6224 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6225 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6226 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6227 HandleDef&: *ImageDef, Pos)) {
6228 return false;
6229 }
6230
6231 auto *SamplerDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: SamplerReg));
6232 Register NewSamplerReg =
6233 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: SamplerReg));
6234 if (!loadHandleBeforePosition(HandleReg&: NewSamplerReg,
6235 ResType: GR.getSPIRVTypeForVReg(VReg: SamplerReg), HandleDef&: *SamplerDef,
6236 Pos)) {
6237 return false;
6238 }
6239
6240 MachineIRBuilder MIRBuilder(Pos);
6241 SPIRVTypeInst SampledImageType = GR.getOrCreateOpTypeSampledImage(
6242 ImageType: GR.getSPIRVTypeForVReg(VReg: ImageReg), MIRBuilder);
6243 Register SampledImageReg =
6244 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: SampledImageType));
6245
6246 BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: Loc, MCID: TII.get(Opcode: SPIRV::OpSampledImage))
6247 .addDef(RegNo: SampledImageReg)
6248 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SampledImageType))
6249 .addUse(RegNo: NewImageReg)
6250 .addUse(RegNo: NewSamplerReg)
6251 .constrainAllUses(TII, TRI, RBI);
6252
6253 bool IsExplicitLod = ImOps.GradX.has_value() || ImOps.GradY.has_value() ||
6254 ImOps.Lod.has_value();
6255 unsigned Opcode = IsExplicitLod ? SPIRV::OpImageSampleExplicitLod
6256 : SPIRV::OpImageSampleImplicitLod;
6257 if (ImOps.Compare)
6258 Opcode = IsExplicitLod ? SPIRV::OpImageSampleDrefExplicitLod
6259 : SPIRV::OpImageSampleDrefImplicitLod;
6260
6261 auto MIB = BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: Loc, MCID: TII.get(Opcode))
6262 .addDef(RegNo: ResVReg)
6263 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6264 .addUse(RegNo: SampledImageReg)
6265 .addUse(RegNo: CoordinateReg);
6266
6267 if (ImOps.Compare)
6268 MIB.addUse(RegNo: *ImOps.Compare);
6269
6270 uint32_t ImageOperands = 0;
6271 if (ImOps.Bias)
6272 ImageOperands |= SPIRV::ImageOperand::Bias;
6273 if (ImOps.Lod)
6274 ImageOperands |= SPIRV::ImageOperand::Lod;
6275 if (ImOps.GradX && ImOps.GradY)
6276 ImageOperands |= SPIRV::ImageOperand::Grad;
6277 if (ImOps.Offset && !isScalarOrVectorIntConstantZero(Reg: *ImOps.Offset)) {
6278 if (isConstReg(MRI, OpReg: *ImOps.Offset))
6279 ImageOperands |= SPIRV::ImageOperand::ConstOffset;
6280 else {
6281 Pos.emitGenericError(
6282 ErrMsg: "Non-constant offsets are not supported in sample instructions.");
6283 return false;
6284 }
6285 }
6286 if (ImOps.MinLod)
6287 ImageOperands |= SPIRV::ImageOperand::MinLod;
6288
6289 if (ImageOperands != 0) {
6290 MIB.addImm(Val: ImageOperands);
6291 if (ImageOperands & SPIRV::ImageOperand::Bias)
6292 MIB.addUse(RegNo: *ImOps.Bias);
6293 if (ImageOperands & SPIRV::ImageOperand::Lod)
6294 MIB.addUse(RegNo: *ImOps.Lod);
6295 if (ImageOperands & SPIRV::ImageOperand::Grad) {
6296 MIB.addUse(RegNo: *ImOps.GradX);
6297 MIB.addUse(RegNo: *ImOps.GradY);
6298 }
6299 if (ImageOperands &
6300 (SPIRV::ImageOperand::ConstOffset | SPIRV::ImageOperand::Offset))
6301 MIB.addUse(RegNo: *ImOps.Offset);
6302 if (ImageOperands & SPIRV::ImageOperand::MinLod)
6303 MIB.addUse(RegNo: *ImOps.MinLod);
6304 }
6305
6306 MIB.constrainAllUses(TII, TRI, RBI);
6307 return true;
6308}
6309
6310bool SPIRVInstructionSelector::selectImageQuerySize(
6311 Register ImageReg, Register &ResVReg, MachineInstr &I,
6312 std::optional<Register> LodReg) const {
6313 SPIRVTypeInst ImageType = GR.getSPIRVTypeForVReg(VReg: ImageReg);
6314 assert(ImageType && ImageType->getOpcode() == SPIRV::OpTypeImage &&
6315 "ImageReg is not an image type.");
6316
6317 auto Dim = static_cast<SPIRV::Dim::Dim>(ImageType->getOperand(i: 2).getImm());
6318 bool IsArray = ImageType->getOperand(i: 4).getImm() != 0;
6319 unsigned NumComponents = 0;
6320 switch (Dim) {
6321 case SPIRV::Dim::DIM_1D:
6322 case SPIRV::Dim::DIM_Buffer:
6323 NumComponents = IsArray ? 2 : 1;
6324 break;
6325 case SPIRV::Dim::DIM_2D:
6326 case SPIRV::Dim::DIM_Cube:
6327 case SPIRV::Dim::DIM_Rect:
6328 NumComponents = IsArray ? 3 : 2;
6329 break;
6330 case SPIRV::Dim::DIM_3D:
6331 NumComponents = 3;
6332 break;
6333 default:
6334 I.emitGenericError(ErrMsg: "Unsupported image dimension for OpImageQuerySize.");
6335 return false;
6336 }
6337
6338 SPIRVTypeInst I32Ty = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
6339 // Non-multisampled 1D, 2D, 3D, and Cube images with Sampled = 1 (compatible
6340 // with sampling operations) require an explicit LOD. Query mip level zero
6341 // when GetDimensions does not supply one.
6342 bool IsSampled = ImageType->getOperand(i: 6).getImm() == 1;
6343 bool IsMultisampled = ImageType->getOperand(i: 5).getImm() != 0;
6344 if (!LodReg && IsSampled && !IsMultisampled &&
6345 Dim != SPIRV::Dim::DIM_Buffer && Dim != SPIRV::Dim::DIM_Rect)
6346 LodReg = GR.getOrCreateConstInt(Val: 0, I, SpvType: I32Ty, TII, ZeroAsNull: !STI.isShader());
6347 unsigned Opcode =
6348 LodReg ? SPIRV::OpImageQuerySizeLod : SPIRV::OpImageQuerySize;
6349 SPIRVTypeInst ResType =
6350 NumComponents == 1
6351 ? I32Ty
6352 : GR.getOrCreateSPIRVVectorType(BaseType: I32Ty, NumElements: NumComponents, I, TII);
6353
6354 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
6355 .addDef(RegNo: ResVReg)
6356 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6357 .addUse(RegNo: ImageReg);
6358 if (LodReg)
6359 MIB.addUse(RegNo: *LodReg);
6360 MIB.constrainAllUses(TII, TRI, RBI);
6361 return true;
6362}
6363
6364bool SPIRVInstructionSelector::selectGetDimensionsIntrinsic(
6365 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6366 Register ImageReg = I.getOperand(i: 2).getReg();
6367 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6368 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6369 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6370 HandleDef&: *ImageDef, Pos&: I)) {
6371 return false;
6372 }
6373 return selectImageQuerySize(ImageReg: NewImageReg, ResVReg, I);
6374}
6375
6376bool SPIRVInstructionSelector::selectGetDimensionsLevelsIntrinsic(
6377 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6378 Register ImageReg = I.getOperand(i: 2).getReg();
6379 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6380 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6381 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6382 HandleDef&: *ImageDef, Pos&: I)) {
6383 return false;
6384 }
6385
6386 Register SizeReg = MRI->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
6387 Register LodReg = I.getOperand(i: 3).getReg();
6388
6389 assert(GR.getSPIRVTypeForVReg(NewImageReg)->getOperand(6).getImm() == 1 &&
6390 "OpImageQuerySizeLod and OpImageQueryLevels require a sampled image");
6391
6392 if (!selectImageQuerySize(ImageReg: NewImageReg, ResVReg&: SizeReg, I, LodReg)) {
6393 return false;
6394 }
6395
6396 SPIRVTypeInst I32Ty = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
6397 Register LevelsReg = MRI->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
6398 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
6399 MCID: TII.get(Opcode: SPIRV::OpImageQueryLevels))
6400 .addDef(RegNo: LevelsReg)
6401 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: I32Ty))
6402 .addUse(RegNo: NewImageReg)
6403 .constrainAllUses(TII, TRI, RBI);
6404
6405 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
6406 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
6407 .addDef(RegNo: ResVReg)
6408 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6409 .addUse(RegNo: SizeReg)
6410 .addUse(RegNo: LevelsReg)
6411 .constrainAllUses(TII, TRI, RBI);
6412
6413 return true;
6414}
6415
6416bool SPIRVInstructionSelector::selectGetDimensionsMSIntrinsic(
6417 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6418 Register ImageReg = I.getOperand(i: 2).getReg();
6419 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6420 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6421 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6422 HandleDef&: *ImageDef, Pos&: I)) {
6423 return false;
6424 }
6425
6426 Register SizeReg = MRI->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
6427
6428 assert(GR.getSPIRVTypeForVReg(NewImageReg)->getOperand(5).getImm() == 1 &&
6429 "OpImageQuerySamples requires a multisampled image");
6430
6431 if (!selectImageQuerySize(ImageReg: NewImageReg, ResVReg&: SizeReg, I)) {
6432 return false;
6433 }
6434
6435 Register SamplesReg = MRI->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
6436
6437 SPIRVTypeInst I32Ty = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
6438 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
6439 MCID: TII.get(Opcode: SPIRV::OpImageQuerySamples))
6440 .addDef(RegNo: SamplesReg)
6441 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: I32Ty))
6442 .addUse(RegNo: NewImageReg)
6443 .constrainAllUses(TII, TRI, RBI);
6444
6445 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
6446 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
6447 .addDef(RegNo: ResVReg)
6448 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6449 .addUse(RegNo: SizeReg)
6450 .addUse(RegNo: SamplesReg)
6451 .constrainAllUses(TII, TRI, RBI);
6452
6453 return true;
6454}
6455
6456bool SPIRVInstructionSelector::selectCalculateLodIntrinsic(
6457 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6458 Register ImageReg = I.getOperand(i: 2).getReg();
6459 Register SamplerReg = I.getOperand(i: 3).getReg();
6460 Register CoordinateReg = I.getOperand(i: 4).getReg();
6461
6462 auto *ImageDef = dyn_cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6463 if (!ImageDef)
6464 return false;
6465 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6466 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6467 HandleDef&: *ImageDef, Pos&: I)) {
6468 return false;
6469 }
6470
6471 auto *SamplerDef = dyn_cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: SamplerReg));
6472 if (!SamplerDef)
6473 return false;
6474 Register NewSamplerReg =
6475 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: SamplerReg));
6476 if (!loadHandleBeforePosition(
6477 HandleReg&: NewSamplerReg, ResType: GR.getSPIRVTypeForVReg(VReg: SamplerReg), HandleDef&: *SamplerDef, Pos&: I)) {
6478 return false;
6479 }
6480
6481 MachineIRBuilder MIRBuilder(I);
6482 SPIRVTypeInst SampledImageType = GR.getOrCreateOpTypeSampledImage(
6483 ImageType: GR.getSPIRVTypeForVReg(VReg: ImageReg), MIRBuilder);
6484 Register SampledImageReg =
6485 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: SampledImageType));
6486
6487 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSampledImage))
6488 .addDef(RegNo: SampledImageReg)
6489 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SampledImageType))
6490 .addUse(RegNo: NewImageReg)
6491 .addUse(RegNo: NewSamplerReg)
6492 .constrainAllUses(TII, TRI, RBI);
6493
6494 SPIRVTypeInst Vec2Ty = GR.getOrCreateSPIRVVectorType(BaseType: ResType, NumElements: 2, I, TII);
6495 Register QueryResultReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: Vec2Ty));
6496
6497 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpImageQueryLod))
6498 .addDef(RegNo: QueryResultReg)
6499 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: Vec2Ty))
6500 .addUse(RegNo: SampledImageReg)
6501 .addUse(RegNo: CoordinateReg)
6502 .constrainAllUses(TII, TRI, RBI);
6503
6504 unsigned ExtractedIndex =
6505 cast<GIntrinsic>(Val&: I).getIntrinsicID() ==
6506 Intrinsic::spv_resource_calculate_lod_unclamped
6507 ? 1
6508 : 0;
6509
6510 MachineInstrBuilder MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
6511 MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
6512 .addDef(RegNo: ResVReg)
6513 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6514 .addUse(RegNo: QueryResultReg)
6515 .addImm(Val: ExtractedIndex);
6516
6517 MIB.constrainAllUses(TII, TRI, RBI);
6518 return true;
6519}
6520
6521bool SPIRVInstructionSelector::selectSampleBasicIntrinsic(
6522 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6523 Register ImageReg = I.getOperand(i: 2).getReg();
6524 Register SamplerReg = I.getOperand(i: 3).getReg();
6525 Register CoordinateReg = I.getOperand(i: 4).getReg();
6526 ImageOperands ImOps;
6527 if (I.getNumOperands() > 5)
6528 ImOps.Offset = I.getOperand(i: 5).getReg();
6529 if (I.getNumOperands() > 6)
6530 ImOps.MinLod = I.getOperand(i: 6).getReg();
6531 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6532 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6533}
6534
6535bool SPIRVInstructionSelector::selectSampleBiasIntrinsic(
6536 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6537 Register ImageReg = I.getOperand(i: 2).getReg();
6538 Register SamplerReg = I.getOperand(i: 3).getReg();
6539 Register CoordinateReg = I.getOperand(i: 4).getReg();
6540 ImageOperands ImOps;
6541 ImOps.Bias = I.getOperand(i: 5).getReg();
6542 if (I.getNumOperands() > 6)
6543 ImOps.Offset = I.getOperand(i: 6).getReg();
6544 if (I.getNumOperands() > 7)
6545 ImOps.MinLod = I.getOperand(i: 7).getReg();
6546 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6547 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6548}
6549
6550bool SPIRVInstructionSelector::selectSampleGradIntrinsic(
6551 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6552 Register ImageReg = I.getOperand(i: 2).getReg();
6553 Register SamplerReg = I.getOperand(i: 3).getReg();
6554 Register CoordinateReg = I.getOperand(i: 4).getReg();
6555 ImageOperands ImOps;
6556 ImOps.GradX = I.getOperand(i: 5).getReg();
6557 ImOps.GradY = I.getOperand(i: 6).getReg();
6558 if (I.getNumOperands() > 7)
6559 ImOps.Offset = I.getOperand(i: 7).getReg();
6560 if (I.getNumOperands() > 8)
6561 ImOps.MinLod = I.getOperand(i: 8).getReg();
6562 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6563 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6564}
6565
6566bool SPIRVInstructionSelector::selectSampleLevelIntrinsic(
6567 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6568 Register ImageReg = I.getOperand(i: 2).getReg();
6569 Register SamplerReg = I.getOperand(i: 3).getReg();
6570 Register CoordinateReg = I.getOperand(i: 4).getReg();
6571 ImageOperands ImOps;
6572 ImOps.Lod = I.getOperand(i: 5).getReg();
6573 if (I.getNumOperands() > 6)
6574 ImOps.Offset = I.getOperand(i: 6).getReg();
6575 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6576 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6577}
6578
6579bool SPIRVInstructionSelector::selectSampleCmpIntrinsic(Register &ResVReg,
6580 SPIRVTypeInst ResType,
6581 MachineInstr &I) const {
6582 Register ImageReg = I.getOperand(i: 2).getReg();
6583 Register SamplerReg = I.getOperand(i: 3).getReg();
6584 Register CoordinateReg = I.getOperand(i: 4).getReg();
6585 ImageOperands ImOps;
6586 ImOps.Compare = I.getOperand(i: 5).getReg();
6587 if (I.getNumOperands() > 6)
6588 ImOps.Offset = I.getOperand(i: 6).getReg();
6589 if (I.getNumOperands() > 7)
6590 ImOps.MinLod = I.getOperand(i: 7).getReg();
6591 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6592 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6593}
6594
6595bool SPIRVInstructionSelector::selectLoadLevelIntrinsic(Register &ResVReg,
6596 SPIRVTypeInst ResType,
6597 MachineInstr &I) const {
6598 Register ImageReg = I.getOperand(i: 2).getReg();
6599 Register CoordinateReg = I.getOperand(i: 3).getReg();
6600 Register LodReg = I.getOperand(i: 4).getReg();
6601
6602 ImageOperands ImOps;
6603 ImOps.Lod = LodReg;
6604 if (I.getNumOperands() > 5)
6605 ImOps.Offset = I.getOperand(i: 5).getReg();
6606
6607 auto *ImageDef = dyn_cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6608 if (!ImageDef)
6609 return false;
6610
6611 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6612 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6613 HandleDef&: *ImageDef, Pos&: I)) {
6614 return false;
6615 }
6616
6617 return generateImageReadOrFetch(ResVReg, ResType, ImageReg: NewImageReg, IdxReg: CoordinateReg,
6618 Loc: I.getDebugLoc(), Pos&: I, ImOps: &ImOps);
6619}
6620
6621bool SPIRVInstructionSelector::selectSampleCmpLevelZeroIntrinsic(
6622 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6623 Register ImageReg = I.getOperand(i: 2).getReg();
6624 Register SamplerReg = I.getOperand(i: 3).getReg();
6625 Register CoordinateReg = I.getOperand(i: 4).getReg();
6626 ImageOperands ImOps;
6627 ImOps.Compare = I.getOperand(i: 5).getReg();
6628 if (I.getNumOperands() > 6)
6629 ImOps.Offset = I.getOperand(i: 6).getReg();
6630 SPIRVTypeInst FloatTy = GR.getOrCreateSPIRVFloatType(BitWidth: 32, I, TII);
6631 ImOps.Lod = GR.getOrCreateConstFP(Val: APFloat(0.0f), I, SpvType: FloatTy, TII);
6632 return generateSampleImage(ResVReg, ResType, ImageReg, SamplerReg,
6633 CoordinateReg, ImOps, Loc: I.getDebugLoc(), Pos&: I);
6634}
6635
6636bool SPIRVInstructionSelector::selectGatherIntrinsic(Register &ResVReg,
6637 SPIRVTypeInst ResType,
6638 MachineInstr &I) const {
6639 Register ImageReg = I.getOperand(i: 2).getReg();
6640 Register SamplerReg = I.getOperand(i: 3).getReg();
6641 Register CoordinateReg = I.getOperand(i: 4).getReg();
6642 SPIRVTypeInst ImageType = GR.getSPIRVTypeForVReg(VReg: ImageReg);
6643 assert(ImageType && ImageType->getOpcode() == SPIRV::OpTypeImage &&
6644 "ImageReg is not an image type.");
6645
6646 Register ComponentOrCompareReg;
6647 Register OffsetReg;
6648
6649 ComponentOrCompareReg = I.getOperand(i: 5).getReg();
6650 OffsetReg = I.getOperand(i: 6).getReg();
6651 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6652 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6653 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: ImageType, HandleDef&: *ImageDef, Pos&: I)) {
6654 return false;
6655 }
6656
6657 auto Dim = static_cast<SPIRV::Dim::Dim>(ImageType->getOperand(i: 2).getImm());
6658 if (Dim != SPIRV::Dim::DIM_2D && Dim != SPIRV::Dim::DIM_Cube &&
6659 Dim != SPIRV::Dim::DIM_Rect) {
6660 I.emitGenericError(
6661 ErrMsg: "Gather operations are only supported for 2D, Cube, and Rect images.");
6662 return false;
6663 }
6664
6665 auto *SamplerDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: SamplerReg));
6666 Register NewSamplerReg =
6667 MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: SamplerReg));
6668 if (!loadHandleBeforePosition(
6669 HandleReg&: NewSamplerReg, ResType: GR.getSPIRVTypeForVReg(VReg: SamplerReg), HandleDef&: *SamplerDef, Pos&: I)) {
6670 return false;
6671 }
6672
6673 MachineIRBuilder MIRBuilder(I);
6674 SPIRVTypeInst SampledImageType =
6675 GR.getOrCreateOpTypeSampledImage(ImageType, MIRBuilder);
6676 Register SampledImageReg =
6677 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: SampledImageType));
6678
6679 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpSampledImage))
6680 .addDef(RegNo: SampledImageReg)
6681 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: SampledImageType))
6682 .addUse(RegNo: NewImageReg)
6683 .addUse(RegNo: NewSamplerReg)
6684 .constrainAllUses(TII, TRI, RBI);
6685
6686 auto IntrId = cast<GIntrinsic>(Val&: I).getIntrinsicID();
6687 bool IsGatherCmp = IntrId == Intrinsic::spv_resource_gather_cmp;
6688 unsigned Opcode =
6689 IsGatherCmp ? SPIRV::OpImageDrefGather : SPIRV::OpImageGather;
6690
6691 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
6692 .addDef(RegNo: ResVReg)
6693 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6694 .addUse(RegNo: SampledImageReg)
6695 .addUse(RegNo: CoordinateReg)
6696 .addUse(RegNo: ComponentOrCompareReg);
6697
6698 uint32_t ImageOperands = 0;
6699 if (OffsetReg && !isScalarOrVectorIntConstantZero(Reg: OffsetReg)) {
6700 if (Dim == SPIRV::Dim::DIM_Cube) {
6701 I.emitGenericError(
6702 ErrMsg: "Gather operations with offset are not supported for Cube images.");
6703 return false;
6704 }
6705 if (isConstReg(MRI, OpReg: OffsetReg))
6706 ImageOperands |= SPIRV::ImageOperand::ConstOffset;
6707 else {
6708 ImageOperands |= SPIRV::ImageOperand::Offset;
6709 }
6710 }
6711
6712 if (ImageOperands != 0) {
6713 MIB.addImm(Val: ImageOperands);
6714 if (ImageOperands &
6715 (SPIRV::ImageOperand::ConstOffset | SPIRV::ImageOperand::Offset))
6716 MIB.addUse(RegNo: OffsetReg);
6717 }
6718
6719 MIB.constrainAllUses(TII, TRI, RBI);
6720 return true;
6721}
6722
6723bool SPIRVInstructionSelector::generateImageReadOrFetch(
6724 Register &ResVReg, SPIRVTypeInst ResType, Register ImageReg,
6725 Register IdxReg, DebugLoc Loc, MachineInstr &Pos,
6726 const ImageOperands *ImOps) const {
6727 SPIRVTypeInst ImageType = GR.getSPIRVTypeForVReg(VReg: ImageReg);
6728 assert(ImageType && ImageType->getOpcode() == SPIRV::OpTypeImage &&
6729 "ImageReg is not an image type.");
6730
6731 bool IsSignedInteger =
6732 sampledTypeIsSignedInteger(HandleType: GR.getTypeForSPIRVType(Ty: ImageType));
6733 // Check if the "sampled" operand of the image type is 1.
6734 // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpImageFetch
6735 auto SampledOp = ImageType->getOperand(i: 6);
6736 bool IsFetch = (SampledOp.getImm() == 1);
6737
6738 auto AddOperands = [&](MachineInstrBuilder &MIB) {
6739 uint32_t ImageOperandsMask = 0;
6740 if (IsSignedInteger)
6741 ImageOperandsMask |= 0x1000; // SignExtend
6742
6743 if (IsFetch && ImOps) {
6744 if (ImOps->Lod)
6745 ImageOperandsMask |= SPIRV::ImageOperand::Lod;
6746 if (ImOps->Offset && !isScalarOrVectorIntConstantZero(Reg: *ImOps->Offset)) {
6747 if (isConstReg(MRI, OpReg: *ImOps->Offset))
6748 ImageOperandsMask |= SPIRV::ImageOperand::ConstOffset;
6749 else
6750 ImageOperandsMask |= SPIRV::ImageOperand::Offset;
6751 }
6752 }
6753
6754 if (ImageOperandsMask != 0) {
6755 MIB.addImm(Val: ImageOperandsMask);
6756 if (IsFetch && ImOps) {
6757 if (ImOps->Lod)
6758 MIB.addUse(RegNo: *ImOps->Lod);
6759 if (ImOps->Offset &&
6760 (ImageOperandsMask &
6761 (SPIRV::ImageOperand::Offset | SPIRV::ImageOperand::ConstOffset)))
6762 MIB.addUse(RegNo: *ImOps->Offset);
6763 }
6764 }
6765 };
6766
6767 uint64_t ResultSize = GR.getScalarOrVectorComponentCount(Type: ResType);
6768
6769 // A wide element (e.g. int64_t2) is emulated with a narrower packed image, so
6770 // its sampled type is different from the result.
6771 SPIRVTypeInst SampledType =
6772 GR.getSPIRVTypeForVReg(VReg: ImageType->getOperand(i: 1).getReg());
6773 bool IsPacked = SampledType != GR.getScalarOrVectorComponentType(Type: ResType);
6774 SPIRVTypeInst ReadType =
6775 widenTypeToVec4(Type: IsPacked ? SampledType : ResType, I&: Pos);
6776 bool ReadTypeMatchesResult = ReadType == ResType;
6777 // Read directly into the result, or into a temporary to bitcast/extract.
6778 Register ReadReg = ReadTypeMatchesResult
6779 ? ResVReg
6780 : MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ReadType));
6781
6782 auto BMI =
6783 BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: Loc,
6784 MCID: TII.get(Opcode: IsFetch ? SPIRV::OpImageFetch : SPIRV::OpImageRead))
6785 .addDef(RegNo: ReadReg)
6786 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ReadType))
6787 .addUse(RegNo: ImageReg)
6788 .addUse(RegNo: IdxReg);
6789 AddOperands(BMI);
6790 BMI.constrainAllUses(TII, TRI, RBI);
6791
6792 if (ReadTypeMatchesResult)
6793 return true;
6794
6795 if (IsPacked) {
6796 // Reinterpret the packed vector as the wide result type.
6797 BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: Loc, MCID: TII.get(Opcode: SPIRV::OpBitcast))
6798 .addDef(RegNo: ResVReg)
6799 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6800 .addUse(RegNo: ReadReg)
6801 .constrainAllUses(TII, TRI, RBI);
6802 return true;
6803 }
6804
6805 if (ResultSize == 1) {
6806 BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: Loc, MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
6807 .addDef(RegNo: ResVReg)
6808 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6809 .addUse(RegNo: ReadReg)
6810 .addImm(Val: 0)
6811 .constrainAllUses(TII, TRI, RBI);
6812 return true;
6813 }
6814 return extractSubvector(ResVReg, ResType, ReadReg, InsertionPoint&: Pos);
6815}
6816
6817bool SPIRVInstructionSelector::selectResourceGetPointer(Register &ResVReg,
6818 SPIRVTypeInst ResType,
6819 MachineInstr &I) const {
6820 Register ResourcePtr = I.getOperand(i: 2).getReg();
6821 SPIRVTypeInst RegType = GR.getSPIRVTypeForVReg(VReg: ResourcePtr, MF: I.getMF());
6822 if (RegType->getOpcode() == SPIRV::OpTypeImage) {
6823 // For texel buffers, the index into the image is part of the OpImageRead or
6824 // OpImageWrite instructions. So we will do nothing in this case. This
6825 // intrinsic will be combined with the load or store when selecting the load
6826 // or store.
6827 return true;
6828 }
6829
6830 assert(ResType->getOpcode() == SPIRV::OpTypePointer);
6831
6832 Register ZeroReg =
6833 buildZerosVal(ResType: GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII), I);
6834 auto MIB =
6835 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAccessChain))
6836 .addDef(RegNo: ResVReg)
6837 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
6838 .addUse(RegNo: ResourcePtr)
6839 .addUse(RegNo: ZeroReg);
6840
6841 if (I.getNumExplicitOperands() > 3) {
6842 Register IndexReg = I.getOperand(i: 3).getReg();
6843 MIB.addUse(RegNo: IndexReg);
6844 }
6845 MIB.constrainAllUses(TII, TRI, RBI);
6846 return true;
6847}
6848
6849bool SPIRVInstructionSelector::selectPushConstantGetPointer(
6850 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6851 MRI->replaceRegWith(FromReg: ResVReg, ToReg: I.getOperand(i: 2).getReg());
6852 return true;
6853}
6854
6855bool SPIRVInstructionSelector::selectResourceNonUniformIndex(
6856 Register &ResVReg, SPIRVTypeInst ResType, MachineInstr &I) const {
6857 Register ObjReg = I.getOperand(i: 2).getReg();
6858 if (!BuildCOPY(DestReg: ResVReg, SrcReg: ObjReg, I))
6859 return false;
6860
6861 buildOpDecorate(Reg: ResVReg, I, TII, Dec: SPIRV::Decoration::NonUniformEXT, DecArgs: {});
6862 // Check for the registers that use the index marked as non-uniform
6863 // and recursively mark them as non-uniform.
6864 // Per the spec, it's necessary that the final argument used for
6865 // load/store/sample/atomic must be decorated, so we need to propagate the
6866 // decoration through access chains and copies.
6867 // https://docs.vulkan.org/samples/latest/samples/extensions/descriptor_indexing/README.html#_when_to_use_non_uniform_indexing_qualifier
6868 decorateUsesAsNonUniform(NonUniformReg&: ResVReg);
6869 return true;
6870}
6871
6872void SPIRVInstructionSelector::decorateUsesAsNonUniform(
6873 Register &NonUniformReg) const {
6874 llvm::SmallVector<std::pair<Register, MachineInstr *>> WorkList = {
6875 {NonUniformReg, nullptr}};
6876 llvm::SmallSet<Register, 8> Visited;
6877 while (WorkList.size() > 0) {
6878 auto [CurrentReg, DefMI] = WorkList.pop_back_val();
6879
6880 if (!Visited.insert(V: CurrentReg).second)
6881 continue;
6882
6883 bool IsDecorated = false;
6884 for (MachineInstr &Use : MRI->use_instructions(Reg: CurrentReg)) {
6885 if (Use.getOpcode() == SPIRV::OpDecorate &&
6886 Use.getOperand(i: 1).getImm() == SPIRV::Decoration::NonUniformEXT) {
6887 IsDecorated = true;
6888 continue;
6889 }
6890 // Check if the instruction has the result register and add it to the
6891 // worklist.
6892 if (Use.getOperand(i: 0).isReg() && Use.getOperand(i: 0).isDef()) {
6893 Register ResultReg = Use.getOperand(i: 0).getReg();
6894 if (ResultReg == CurrentReg)
6895 continue;
6896 WorkList.push_back(Elt: {ResultReg, &Use});
6897 }
6898 }
6899
6900 if (!IsDecorated) {
6901 MachineBasicBlock &MBB = *DefMI->getParent();
6902 MachineInstr &InsertPt =
6903 DefMI->isPHI() ? *MBB.getFirstNonPHI() : *DefMI->getNextNode();
6904 buildOpDecorate(Reg: CurrentReg, I&: InsertPt, TII,
6905 Dec: SPIRV::Decoration::NonUniformEXT, DecArgs: {});
6906 }
6907 }
6908}
6909
6910bool SPIRVInstructionSelector::extractSubvector(
6911 Register &ResVReg, SPIRVTypeInst ResType, Register &ReadReg,
6912 MachineInstr &InsertionPoint) const {
6913 SPIRVTypeInst InputType = GR.getResultType(VReg: ReadReg);
6914 [[maybe_unused]] uint64_t InputSize =
6915 GR.getScalarOrVectorComponentCount(Type: InputType);
6916 uint64_t ResultSize = GR.getScalarOrVectorComponentCount(Type: ResType);
6917 [[maybe_unused]] bool IsLongVectorEXT =
6918 STI.canUseExtension(E: SPIRV::Extension::SPV_EXT_long_vector);
6919 assert((InputSize > 1 || IsLongVectorEXT) && "The input must be a vector.");
6920 assert((ResultSize > 1 || IsLongVectorEXT) && "The result must be a vector.");
6921 assert(ResultSize < InputSize &&
6922 "Cannot extract more element than there are in the input.");
6923 SmallVector<Register> ComponentRegisters;
6924 SPIRVTypeInst ScalarType = GR.getScalarOrVectorComponentType(Type: ResType);
6925 const TargetRegisterClass *ScalarRegClass = GR.getRegClass(SpvType: ScalarType);
6926 for (uint64_t I = 0; I < ResultSize; I++) {
6927 Register ComponentReg = MRI->createVirtualRegister(RegClass: ScalarRegClass);
6928 BuildMI(BB&: *InsertionPoint.getParent(), I&: InsertionPoint,
6929 MIMD: InsertionPoint.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
6930 .addDef(RegNo: ComponentReg)
6931 .addUse(RegNo: ScalarType->getOperand(i: 0).getReg())
6932 .addUse(RegNo: ReadReg)
6933 .addImm(Val: I)
6934 .constrainAllUses(TII, TRI, RBI);
6935 ComponentRegisters.emplace_back(Args&: ComponentReg);
6936 }
6937
6938 MachineInstrBuilder MIB = BuildMI(BB&: *InsertionPoint.getParent(), I&: InsertionPoint,
6939 MIMD: InsertionPoint.getDebugLoc(),
6940 MCID: TII.get(Opcode: SPIRV::OpCompositeConstruct))
6941 .addDef(RegNo: ResVReg)
6942 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
6943
6944 for (Register ComponentReg : ComponentRegisters)
6945 MIB.addUse(RegNo: ComponentReg);
6946 MIB.constrainAllUses(TII, TRI, RBI);
6947 return true;
6948}
6949
6950bool SPIRVInstructionSelector::selectImageWriteIntrinsic(
6951 MachineInstr &I) const {
6952 // If the load of the image is in a different basic block, then
6953 // this will generate invalid code. A proper solution is to move
6954 // the OpLoad from selectHandleFromBinding here. However, to do
6955 // that we will need to change the return type of the intrinsic.
6956 // We will do that when we can, but for now trying to move forward with other
6957 // issues.
6958 Register ImageReg = I.getOperand(i: 1).getReg();
6959 auto *ImageDef = cast<GIntrinsic>(Val: getVRegDef(MRI&: *MRI, Reg: ImageReg));
6960 Register NewImageReg = MRI->createVirtualRegister(RegClass: MRI->getRegClass(Reg: ImageReg));
6961 if (!loadHandleBeforePosition(HandleReg&: NewImageReg, ResType: GR.getSPIRVTypeForVReg(VReg: ImageReg),
6962 HandleDef&: *ImageDef, Pos&: I)) {
6963 return false;
6964 }
6965
6966 Register CoordinateReg = I.getOperand(i: 2).getReg();
6967 Register DataReg = I.getOperand(i: 3).getReg();
6968 assert(isVectorType(GR.getResultType(DataReg)));
6969 assert(GR.getScalarOrVectorComponentCount(GR.getResultType(DataReg)) == 4);
6970 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpImageWrite))
6971 .addUse(RegNo: NewImageReg)
6972 .addUse(RegNo: CoordinateReg)
6973 .addUse(RegNo: DataReg)
6974 .constrainAllUses(TII, TRI, RBI);
6975 return true;
6976}
6977
6978Register SPIRVInstructionSelector::buildPointerToResource(
6979 SPIRVTypeInst SpirvResType, SPIRV::StorageClass::StorageClass SC,
6980 uint32_t Set, uint32_t Binding, uint32_t ArraySize, Register IndexReg,
6981 StringRef Name, MachineIRBuilder MIRBuilder) const {
6982 const Type *ResType = GR.getTypeForSPIRVType(Ty: SpirvResType);
6983 if (ArraySize == 1) {
6984 SPIRVTypeInst PtrType =
6985 GR.getOrCreateSPIRVPointerType(BaseType: ResType, MIRBuilder, SC);
6986 assert(GR.getPointeeType(PtrType) == SpirvResType &&
6987 "SpirvResType did not have an explicit layout.");
6988 return GR.getOrCreateGlobalVariableWithBinding(VarType: PtrType, Set, Binding, Name,
6989 MIRBuilder);
6990 }
6991
6992 const Type *VarType = ArrayType::get(ElementType: const_cast<Type *>(ResType), NumElements: ArraySize);
6993 SPIRVTypeInst VarPointerType =
6994 GR.getOrCreateSPIRVPointerType(BaseType: VarType, MIRBuilder, SC);
6995 Register VarReg = GR.getOrCreateGlobalVariableWithBinding(
6996 VarType: VarPointerType, Set, Binding, Name, MIRBuilder);
6997
6998 SPIRVTypeInst ResPointerType =
6999 GR.getOrCreateSPIRVPointerType(BaseType: ResType, MIRBuilder, SC);
7000 Register AcReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResPointerType));
7001
7002 MIRBuilder.buildInstr(Opcode: SPIRV::OpAccessChain)
7003 .addDef(RegNo: AcReg)
7004 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResPointerType))
7005 .addUse(RegNo: VarReg)
7006 .addUse(RegNo: IndexReg);
7007
7008 return AcReg;
7009}
7010
7011bool SPIRVInstructionSelector::selectFirstBitSet16(
7012 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I,
7013 unsigned ExtendOpcode, unsigned BitSetOpcode) const {
7014 Register ExtReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7015 if (!selectOpWithSrcs(ResVReg: ExtReg, ResType, I, Srcs: {I.getOperand(i: 2).getReg()},
7016 Opcode: ExtendOpcode))
7017 return false;
7018
7019 return selectFirstBitSet32(ResVReg, ResType, I, SrcReg: ExtReg, BitSetOpcode);
7020}
7021
7022bool SPIRVInstructionSelector::selectFirstBitSet32(
7023 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, Register SrcReg,
7024 unsigned BitSetOpcode) const {
7025 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
7026 .addDef(RegNo: ResVReg)
7027 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7028 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
7029 .addImm(Val: BitSetOpcode)
7030 .addUse(RegNo: SrcReg)
7031 .constrainAllUses(TII, TRI, RBI);
7032 return true;
7033}
7034
7035bool SPIRVInstructionSelector::selectFirstBitSet64(
7036 Register ResVReg, SPIRVTypeInst ResType, MachineInstr &I, Register SrcReg,
7037 unsigned BitSetOpcode, bool SwapPrimarySide) const {
7038 unsigned ComponentCount = GR.getScalarOrVectorComponentCount(Type: ResType);
7039 SPIRVTypeInst BaseType = GR.retrieveScalarOrVectorIntType(Type: ResType);
7040 bool ZeroAsNull = !STI.isShader();
7041 Register ConstIntZero =
7042 GR.getOrCreateConstInt(Val: 0, I, SpvType: BaseType, TII, ZeroAsNull);
7043 Register ConstIntOne =
7044 GR.getOrCreateConstInt(Val: 1, I, SpvType: BaseType, TII, ZeroAsNull);
7045
7046 // SPIRV doesn't support vectors with more than 4 components. Since the
7047 // algoritm below converts i64 -> i32x2 and i64x4 -> i32x8 it can only
7048 // operate on vectors with 2 or less components. When largers vectors are
7049 // seen. Split them, recurse, then recombine them.
7050 // TODO: handle the case where SPV_EXT_long_vector is enabled.
7051 if (ComponentCount > 2) {
7052 auto Func = [this, SwapPrimarySide](Register ResVReg, SPIRVTypeInst ResType,
7053 MachineInstr &I, Register SrcReg,
7054 unsigned Opcode) -> bool {
7055 return this->selectFirstBitSet64(ResVReg, ResType, I, SrcReg, BitSetOpcode: Opcode,
7056 SwapPrimarySide);
7057 };
7058
7059 return handle64BitOverflow(ResVReg, ResType, I, SrcReg, Opcode: BitSetOpcode, CallbackFunction: Func);
7060 }
7061
7062 // 1. Split int64 into 2 pieces using a bitcast
7063 MachineIRBuilder MIRBuilder(I);
7064 SPIRVTypeInst PostCastType = GR.getOrCreateSPIRVVectorType(
7065 BaseType, NumElements: 2 * ComponentCount, MIRBuilder, EmitIR: false);
7066 Register BitcastReg =
7067 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: PostCastType));
7068
7069 if (!selectOpWithSrcs(ResVReg: BitcastReg, ResType: PostCastType, I, Srcs: {SrcReg},
7070 Opcode: SPIRV::OpBitcast))
7071 return false;
7072
7073 // 2. Find the first set bit from the primary side for all the pieces in #1
7074 Register FBSReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: PostCastType));
7075 if (!selectFirstBitSet32(ResVReg: FBSReg, ResType: PostCastType, I, SrcReg: BitcastReg, BitSetOpcode))
7076 return false;
7077
7078 // 3. Split result vector into high bits and low bits
7079 Register HighReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7080 Register LowReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7081
7082 bool IsScalarRes = !isVectorType(SPVTy: ResType);
7083 if (IsScalarRes) {
7084 // if scalar do a vector extract
7085 if (!selectOpWithSrcs(ResVReg: HighReg, ResType, I, Srcs: {FBSReg, ConstIntOne},
7086 Opcode: SPIRV::OpVectorExtractDynamic))
7087 return false;
7088 if (!selectOpWithSrcs(ResVReg: LowReg, ResType, I, Srcs: {FBSReg, ConstIntZero},
7089 Opcode: SPIRV::OpVectorExtractDynamic))
7090 return false;
7091 } else {
7092 // if vector do a shufflevector
7093 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
7094 MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
7095 .addDef(RegNo: HighReg)
7096 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7097 .addUse(RegNo: FBSReg)
7098 // Per the spec, repeat the vector if only one vec is needed
7099 .addUse(RegNo: FBSReg);
7100
7101 // high bits are stored in even natural indexes. Extract them from FBSReg
7102 for (unsigned J = 1; J < ComponentCount * 2; J += 2) {
7103 MIB.addImm(Val: J);
7104 }
7105
7106 MIB.constrainAllUses(TII, TRI, RBI);
7107
7108 MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(),
7109 MCID: TII.get(Opcode: SPIRV::OpVectorShuffle))
7110 .addDef(RegNo: LowReg)
7111 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7112 .addUse(RegNo: FBSReg)
7113 // Per the spec, repeat the vector if only one vec is needed
7114 .addUse(RegNo: FBSReg);
7115
7116 // low bits are stored in odd natural indices. Extract them from FBSReg
7117 for (unsigned J = 0; J < ComponentCount * 2; J += 2) {
7118 MIB.addImm(Val: J);
7119 }
7120 MIB.constrainAllUses(TII, TRI, RBI);
7121 }
7122
7123 // 4. Check the result. When primary bits == -1 use secondary, otherwise use
7124 // primary
7125 SPIRVTypeInst BoolType = GR.getOrCreateSPIRVBoolType(I, TII);
7126 Register NegOneReg;
7127 Register Reg0;
7128 Register Reg32;
7129 unsigned SelectOp;
7130 unsigned AddOp;
7131
7132 if (IsScalarRes) {
7133 NegOneReg =
7134 GR.getOrCreateConstInt(Val: (unsigned)-1, I, SpvType: ResType, TII, ZeroAsNull);
7135 Reg0 = GR.getOrCreateConstInt(Val: 0, I, SpvType: ResType, TII, ZeroAsNull);
7136 Reg32 = GR.getOrCreateConstInt(Val: 32, I, SpvType: ResType, TII, ZeroAsNull);
7137 SelectOp = SPIRV::OpSelectSISCond;
7138 AddOp = SPIRV::OpIAddS;
7139 } else {
7140 BoolType = GR.getOrCreateSPIRVVectorType(BaseType: BoolType, NumElements: ComponentCount,
7141 MIRBuilder, EmitIR: false);
7142 NegOneReg =
7143 GR.getOrCreateConstVector(Val: (unsigned)-1, I, SpvType: ResType, TII, ZeroAsNull);
7144 Reg0 = GR.getOrCreateConstVector(Val: 0, I, SpvType: ResType, TII, ZeroAsNull);
7145 Reg32 = GR.getOrCreateConstVector(Val: 32, I, SpvType: ResType, TII, ZeroAsNull);
7146 SelectOp = SPIRV::OpSelectVIVCond;
7147 AddOp = SPIRV::OpIAddV;
7148 }
7149
7150 Register PrimaryReg = HighReg;
7151 Register SecondaryReg = LowReg;
7152 Register RegPrimaryOffset = Reg32;
7153 Register RegSecondaryOffset = Reg0;
7154
7155 // By default the emitted opcodes check for the set bit from the MSB side.
7156 // Setting SwapPrimarySide checks the set bit from the LSB side
7157 if (SwapPrimarySide) {
7158 PrimaryReg = LowReg;
7159 SecondaryReg = HighReg;
7160 RegPrimaryOffset = Reg0;
7161 RegSecondaryOffset = Reg32;
7162 }
7163
7164 Register RegSecondaryHasVal =
7165 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: BoolType));
7166 if (!selectOpWithSrcs(ResVReg: RegSecondaryHasVal, ResType: BoolType, I,
7167 Srcs: {SecondaryReg, NegOneReg}, Opcode: SPIRV::OpINotEqual))
7168 return false;
7169
7170 Register RegPrimaryHasVal =
7171 MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: BoolType));
7172 if (!selectOpWithSrcs(ResVReg: RegPrimaryHasVal, ResType: BoolType, I, Srcs: {PrimaryReg, NegOneReg},
7173 Opcode: SPIRV::OpINotEqual))
7174 return false;
7175
7176 // Pass 1: seed with secondary (lower-priority fallback)
7177 // ReturnBits = secondaryHasVal ? SecondaryBits : -1
7178 // Add = secondaryHasVal ? SecondaryOffset : 0
7179 Register RegReturnBits = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7180 if (!selectOpWithSrcs(ResVReg: RegReturnBits, ResType, I,
7181 Srcs: {RegSecondaryHasVal, SecondaryReg, NegOneReg},
7182 Opcode: SelectOp))
7183 return false;
7184
7185 Register RegAdd;
7186 if (SwapPrimarySide) {
7187 RegAdd = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7188 if (!selectOpWithSrcs(ResVReg: RegAdd, ResType, I,
7189 Srcs: {RegSecondaryHasVal, RegSecondaryOffset, Reg0},
7190 Opcode: SelectOp))
7191 return false;
7192 } else {
7193 RegAdd = Reg0;
7194 }
7195
7196 // Pass 2: override with primary (higher priority) if it has a valid result
7197 // ReturnBits2 = primaryHasVal ? PrimaryBits : ReturnBits
7198 // Add2 = primaryHasVal ? PrimaryOffset : Add
7199 Register RegReturnBits2 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7200 if (!selectOpWithSrcs(ResVReg: RegReturnBits2, ResType, I,
7201 Srcs: {RegPrimaryHasVal, PrimaryReg, RegReturnBits},
7202 Opcode: SelectOp))
7203 return false;
7204
7205 Register RegAdd2 = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7206 if (!selectOpWithSrcs(ResVReg: RegAdd2, ResType, I,
7207 Srcs: {RegPrimaryHasVal, RegPrimaryOffset, RegAdd}, Opcode: SelectOp))
7208 return false;
7209
7210 return selectOpWithSrcs(ResVReg, ResType, I, Srcs: {RegReturnBits2, RegAdd2},
7211 Opcode: AddOp);
7212}
7213
7214bool SPIRVInstructionSelector::selectFirstBitHigh(Register ResVReg,
7215 SPIRVTypeInst ResType,
7216 MachineInstr &I,
7217 bool IsSigned) const {
7218 // FindUMsb and FindSMsb intrinsics only support 32 bit integers
7219 Register OpReg = I.getOperand(i: 2).getReg();
7220 SPIRVTypeInst OpType = GR.getSPIRVTypeForVReg(VReg: OpReg);
7221 // zero or sign extend
7222 unsigned ExtendOpcode = IsSigned ? SPIRV::OpSConvert : SPIRV::OpUConvert;
7223 unsigned BitSetOpcode = IsSigned ? GL::FindSMsb : GL::FindUMsb;
7224
7225 switch (GR.getScalarOrVectorBitWidth(Type: OpType)) {
7226 case 16:
7227 return selectFirstBitSet16(ResVReg, ResType, I, ExtendOpcode, BitSetOpcode);
7228 case 32:
7229 return selectFirstBitSet32(ResVReg, ResType, I, SrcReg: OpReg, BitSetOpcode);
7230 case 64:
7231 return selectFirstBitSet64(ResVReg, ResType, I, SrcReg: OpReg, BitSetOpcode,
7232 /*SwapPrimarySide=*/false);
7233 default:
7234 return diagnoseUnsupported(
7235 I,
7236 Msg: "spv_firstbituhigh and spv_firstbitshigh only support 16,32,64 bits.");
7237 }
7238}
7239
7240bool SPIRVInstructionSelector::selectFirstBitLow(Register ResVReg,
7241 SPIRVTypeInst ResType,
7242 MachineInstr &I) const {
7243 // FindILsb intrinsic only supports 32 bit integers
7244 Register OpReg = I.getOperand(i: 2).getReg();
7245 SPIRVTypeInst OpType = GR.getSPIRVTypeForVReg(VReg: OpReg);
7246 // OpUConvert treats the operand bits as an unsigned i16 and zero extends it
7247 // to an unsigned i32. As this leaves all the least significant bits unchanged
7248 // so the first set bit from the LSB side doesn't change.
7249 unsigned ExtendOpcode = SPIRV::OpUConvert;
7250 unsigned BitSetOpcode = GL::FindILsb;
7251
7252 switch (GR.getScalarOrVectorBitWidth(Type: OpType)) {
7253 case 16:
7254 return selectFirstBitSet16(ResVReg, ResType, I, ExtendOpcode, BitSetOpcode);
7255 case 32:
7256 return selectFirstBitSet32(ResVReg, ResType, I, SrcReg: OpReg, BitSetOpcode);
7257 case 64:
7258 return selectFirstBitSet64(ResVReg, ResType, I, SrcReg: OpReg, BitSetOpcode,
7259 /*SwapPrimarySide=*/true);
7260 default:
7261 return diagnoseUnsupported(I,
7262 Msg: "spv_firstbitlow only supports 16,32,64 bits.");
7263 }
7264}
7265
7266bool SPIRVInstructionSelector::selectAllocaArray(Register ResVReg,
7267 SPIRVTypeInst ResType,
7268 MachineInstr &I) const {
7269 // there was an allocation size parameter to the allocation instruction
7270 // that is not 1
7271 MachineBasicBlock &BB = *I.getParent();
7272
7273 bool UseUntypedPointers =
7274 ResType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
7275 unsigned Opcode = UseUntypedPointers
7276 ? SPIRV::OpUntypedVariableLengthArrayINTEL
7277 : SPIRV::OpVariableLengthArrayINTEL;
7278
7279 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
7280 .addDef(RegNo: ResVReg)
7281 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
7282
7283 // OpUntypedVariableLengthArrayINTEL takes an explicit Element Type <id>
7284 // right after the result type
7285 if (UseUntypedPointers) {
7286 SPIRVTypeInst ElementType = GR.getUntypedPtrElementType(Reg: ResVReg);
7287 assert(ElementType &&
7288 "untyped variable length array result must have a recorded element "
7289 "type");
7290 MIB.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ElementType));
7291 }
7292
7293 MIB.addUse(RegNo: I.getOperand(i: 2).getReg());
7294 MIB.constrainAllUses(TII, TRI, RBI);
7295
7296 if (!STI.isShader()) {
7297 unsigned Alignment = I.getOperand(i: 3).getImm();
7298 buildOpDecorate(Reg: ResVReg, I, TII, Dec: SPIRV::Decoration::Alignment, DecArgs: {Alignment});
7299 }
7300 return true;
7301}
7302
7303// Returns true iff `Ty` is a concrete SPIR-V type per the SPV_KHR_abort
7304// definition: a numerical scalar (int/float), a (physical) pointer, a vector,
7305// matrix or any aggregate (array/struct) recursively containing only such
7306// types. OpTypeBool, OpTypeVoid, opaque handles and similar abstract
7307// non-concrete types are rejected.
7308static bool isConcreteSPIRVType(SPIRVTypeInst Ty,
7309 const SPIRVGlobalRegistry &GR) {
7310 SmallVector<SPIRVTypeInst, 4> Worklist{Ty};
7311 while (!Worklist.empty()) {
7312 SPIRVTypeInst T = Worklist.pop_back_val();
7313 switch (T->getOpcode()) {
7314 case SPIRV::OpTypeInt:
7315 case SPIRV::OpTypeFloat:
7316 case SPIRV::OpTypePointer:
7317 break;
7318 case SPIRV::OpTypeVector:
7319 case SPIRV::OpTypeVectorIdEXT:
7320 case SPIRV::OpTypeMatrix:
7321 case SPIRV::OpTypeArray: {
7322 Register OperandReg = T->getOperand(i: 1).getReg();
7323 SPIRVTypeInst ElementT = GR.getSPIRVTypeForVReg(VReg: OperandReg);
7324 Worklist.push_back(Elt: ElementT);
7325 } break;
7326 case SPIRV::OpTypeStruct:
7327 for (unsigned Idx = 1, E = T->getNumOperands(); Idx < E; ++Idx) {
7328 Register OperandReg = T->getOperand(i: Idx).getReg();
7329 SPIRVTypeInst ElementT = GR.getSPIRVTypeForVReg(VReg: OperandReg);
7330 Worklist.push_back(Elt: ElementT);
7331 }
7332 break;
7333 default:
7334 return false;
7335 }
7336 }
7337 return true;
7338}
7339
7340static bool containsStorageBufferPointer(SPIRVTypeInst Ty,
7341 const SPIRVGlobalRegistry &GR,
7342 SmallSet<Register, 8> &Visited) {
7343 Register TypeReg = Ty->getOperand(i: 0).getReg();
7344 if (!Visited.insert(V: TypeReg).second)
7345 return false;
7346
7347 switch (Ty->getOpcode()) {
7348 case SPIRV::OpTypePointer:
7349 if (Ty->getOperand(i: 1).getImm() == SPIRV::StorageClass::StorageBuffer)
7350 return true;
7351 return containsStorageBufferPointer(
7352 Ty: GR.getSPIRVTypeForVReg(VReg: Ty->getOperand(i: 2).getReg()), GR, Visited);
7353 case SPIRV::OpTypeArray:
7354 case SPIRV::OpTypeRuntimeArray:
7355 return containsStorageBufferPointer(
7356 Ty: GR.getSPIRVTypeForVReg(VReg: Ty->getOperand(i: 1).getReg()), GR, Visited);
7357 case SPIRV::OpTypeStruct:
7358 for (unsigned I = 1; I < Ty->getNumOperands(); ++I)
7359 if (containsStorageBufferPointer(
7360 Ty: GR.getSPIRVTypeForVReg(VReg: Ty->getOperand(i: I).getReg()), GR, Visited))
7361 return true;
7362 return false;
7363 default:
7364 return false;
7365 }
7366}
7367
7368static bool containsStorageBufferPointer(SPIRVTypeInst Ty,
7369 const SPIRVGlobalRegistry &GR) {
7370 SmallSet<Register, 8> Visited;
7371 return containsStorageBufferPointer(Ty, GR, Visited);
7372}
7373
7374bool SPIRVInstructionSelector::selectAbort(MachineInstr &I) const {
7375 assert(I.getNumExplicitOperands() == 2);
7376
7377 Register MsgReg = I.getOperand(i: 1).getReg();
7378 SPIRVTypeInst MsgType = GR.getSPIRVTypeForVReg(VReg: MsgReg);
7379 assert(MsgType && "Message argument of llvm.spv.abort has no SPIR-V type");
7380
7381 if (!isConcreteSPIRVType(Ty: MsgType, GR))
7382 return diagnoseUnsupported(
7383 I,
7384 Msg: "llvm.spv.abort message type must be a concrete SPIR-V type (numerical "
7385 "scalar, pointer, vector, matrix, or aggregate of such types)");
7386
7387 MachineBasicBlock &BB = *I.getParent();
7388 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAbortKHR))
7389 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: MsgType))
7390 .addUse(RegNo: MsgReg)
7391 .constrainAllUses(TII, TRI, RBI);
7392 return true;
7393}
7394
7395bool SPIRVInstructionSelector::selectTrap(MachineInstr &I) const {
7396 // When the SPV_KHR_abort extension is disabled, drop the G_TRAP and
7397 // G_UBSANTRAP silently. Also drop the no-op placeholder of the service
7398 // function.
7399 if (!STI.canUseExtension(E: SPIRV::Extension::SPV_KHR_abort) ||
7400 I.getMF()->getFunction().hasFnAttribute(SPIRV_BACKEND_SERVICE_FUN_NAME))
7401 return true;
7402
7403 // Use the 32-bit integer constant for the abort "message" argument:
7404 // - G_UBSANTRAP operand is zero-extended to 32 bits.
7405 // - "All ones" constant is used for G_TRAP.
7406 uint32_t MsgVal = ~0u;
7407 if (I.getOpcode() == TargetOpcode::G_UBSANTRAP)
7408 MsgVal = static_cast<uint32_t>(I.getOperand(i: 0).getImm());
7409
7410 SPIRVTypeInst MsgType = GR.getOrCreateSPIRVIntegerType(BitWidth: 32, I, TII);
7411 Register MsgReg = buildI32ConstantInEntryBlock(Val: MsgVal, I, ResType: MsgType);
7412
7413 MachineBasicBlock &BB = *I.getParent();
7414 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpAbortKHR))
7415 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: MsgType))
7416 .addUse(RegNo: MsgReg)
7417 .constrainAllUses(TII, TRI, RBI);
7418 return true;
7419}
7420
7421bool SPIRVInstructionSelector::selectFrameIndex(Register ResVReg,
7422 SPIRVTypeInst ResType,
7423 MachineInstr &I) const {
7424 // Change order of instructions if needed: all OpVariable instructions in a
7425 // function must be the first instructions in the first block
7426 auto It = getOpVariableMBBIt(MF&: *I.getMF());
7427
7428 // Pointers to opaque types stay typed even with the extension on, so emit the
7429 // untyped variant only when the result is actually an untyped pointer.
7430 bool UseUntypedPointers =
7431 ResType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
7432 unsigned Opcode =
7433 UseUntypedPointers ? SPIRV::OpUntypedVariableKHR : SPIRV::OpVariable;
7434
7435 if (!UseUntypedPointers && containsStorageBufferPointer(Ty: ResType, GR)) {
7436 MachineIRBuilder MIRBuilder(I);
7437 if (!STI.isAtLeastSPIRVVer(VerToCompareTo: VersionTuple(1, 3)))
7438 MIRBuilder.buildInstr(Opcode: SPIRV::OpExtension)
7439 .addImm(Val: SPIRV::Extension::SPV_KHR_variable_pointers);
7440 MIRBuilder.buildInstr(Opcode: SPIRV::OpCapability)
7441 .addImm(Val: SPIRV::Capability::VariablePointersStorageBuffer);
7442 }
7443
7444 auto MIB = BuildMI(BB&: *It->getParent(), I: It, MIMD: It->getDebugLoc(), MCID: TII.get(Opcode))
7445 .addDef(RegNo: ResVReg)
7446 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7447 .addImm(Val: static_cast<uint32_t>(SPIRV::StorageClass::Function));
7448
7449 // OpUntypedVariableKHR takes an extra Data Type operand right after the
7450 // storage class.
7451 if (UseUntypedPointers) {
7452 // Get the element type that was stored when processing spv_assign_ptr_type.
7453 SPIRVTypeInst DataType = GR.getUntypedPtrElementType(Reg: ResVReg);
7454 if (!DataType)
7455 return diagnoseUnsupported(
7456 I, Msg: "could not deduce the data type of an untyped variable");
7457 MIB.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: DataType));
7458 }
7459 MIB.constrainAllUses(TII, TRI, RBI);
7460
7461 if (!STI.isShader()) {
7462 unsigned Alignment = I.getOperand(i: 2).getImm();
7463 buildOpDecorate(Reg: ResVReg, I&: *It, TII, Dec: SPIRV::Decoration::Alignment,
7464 DecArgs: {Alignment});
7465 }
7466 return true;
7467}
7468
7469bool SPIRVInstructionSelector::selectBranch(MachineInstr &I) const {
7470 // InstructionSelector walks backwards through the instructions. We can use
7471 // both a G_BR and a G_BRCOND to create an OpBranchConditional. We hit G_BR
7472 // first, so can generate an OpBranchConditional here. If there is no
7473 // G_BRCOND, we just use OpBranch for a regular unconditional branch.
7474 const MachineInstr *PrevI = I.getPrevNode();
7475 MachineBasicBlock &MBB = *I.getParent();
7476 if (PrevI != nullptr && PrevI->getOpcode() == TargetOpcode::G_BRCOND) {
7477 BuildMI(BB&: MBB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBranchConditional))
7478 .addUse(RegNo: PrevI->getOperand(i: 0).getReg())
7479 .addMBB(MBB: PrevI->getOperand(i: 1).getMBB())
7480 .addMBB(MBB: I.getOperand(i: 0).getMBB())
7481 .constrainAllUses(TII, TRI, RBI);
7482 return true;
7483 }
7484 BuildMI(BB&: MBB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBranch))
7485 .addMBB(MBB: I.getOperand(i: 0).getMBB())
7486 .constrainAllUses(TII, TRI, RBI);
7487 return true;
7488}
7489
7490bool SPIRVInstructionSelector::selectBranchCond(MachineInstr &I) const {
7491 // InstructionSelector walks backwards through the instructions. For an
7492 // explicit conditional branch with no fallthrough, we use both a G_BR and a
7493 // G_BRCOND to create an OpBranchConditional. We should hit G_BR first, and
7494 // generate the OpBranchConditional in selectBranch above.
7495 //
7496 // If an OpBranchConditional has been generated, we simply return, as the work
7497 // is alread done. If there is no OpBranchConditional, LLVM must be relying on
7498 // implicit fallthrough to the next basic block, so we need to create an
7499 // OpBranchConditional with an explicit "false" argument pointing to the next
7500 // basic block that LLVM would fall through to.
7501 const MachineInstr *NextI = I.getNextNode();
7502 // Check if this has already been successfully selected.
7503 if (NextI != nullptr && NextI->getOpcode() == SPIRV::OpBranchConditional)
7504 return true;
7505 // Must be relying on implicit block fallthrough, so generate an
7506 // OpBranchConditional with the "next" basic block as the "false" target.
7507 MachineBasicBlock &MBB = *I.getParent();
7508 unsigned NextMBBNum = MBB.getNextNode()->getNumber();
7509 MachineBasicBlock *NextMBB = I.getMF()->getBlockNumbered(N: NextMBBNum);
7510 BuildMI(BB&: MBB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpBranchConditional))
7511 .addUse(RegNo: I.getOperand(i: 0).getReg())
7512 .addMBB(MBB: I.getOperand(i: 1).getMBB())
7513 .addMBB(MBB: NextMBB)
7514 .constrainAllUses(TII, TRI, RBI);
7515 return true;
7516}
7517
7518bool SPIRVInstructionSelector::selectPhi(Register ResVReg,
7519 MachineInstr &I) const {
7520 auto MIB =
7521 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: TargetOpcode::PHI))
7522 .addDef(RegNo: ResVReg);
7523 const unsigned NumOps = I.getNumOperands();
7524 for (unsigned i = 1; i < NumOps; i += 2) {
7525 MIB.addUse(RegNo: I.getOperand(i: i + 0).getReg());
7526 MIB.addMBB(MBB: I.getOperand(i: i + 1).getMBB());
7527 }
7528 MIB.constrainAllUses(TII, TRI, RBI);
7529 return true;
7530}
7531
7532bool SPIRVInstructionSelector::selectGlobalValue(
7533 Register ResVReg, MachineInstr &I, const MachineInstr *Init) const {
7534 // FIXME: don't use MachineIRBuilder here, replace it with BuildMI.
7535 MachineIRBuilder MIRBuilder(I);
7536 const GlobalValue *GV = I.getOperand(i: 1).getGlobal();
7537 Type *GVType = toTypedPointer(Ty: GR.getDeducedGlobalValueType(Global: GV));
7538
7539 std::string GlobalIdent;
7540 if (!GV->hasName()) {
7541 unsigned &ID = UnnamedGlobalIDs[GV];
7542 if (ID == 0)
7543 ID = UnnamedGlobalIDs.size();
7544 GlobalIdent = "__unnamed_" + Twine(ID).str();
7545 } else {
7546 GlobalIdent = GV->getName();
7547 }
7548
7549 // Behaviour of functions as operands depends on availability of the
7550 // corresponding extension (SPV_INTEL_function_pointers):
7551 // - If there is an extension to operate with functions as operands:
7552 // We create a proper constant operand and evaluate a correct type for a
7553 // function pointer.
7554 // - Without the required extension:
7555 // We have functions as operands in tests with blocks of instruction e.g. in
7556 // transcoding/global_block.ll. These operands are not used and should be
7557 // substituted by zero constants. Their type is expected to be always
7558 // OpTypePointer Function %uchar.
7559 if (isa<Function>(Val: GV)) {
7560 const Constant *ConstVal = GV;
7561 MachineBasicBlock &BB = *I.getParent();
7562 Register NewReg = GR.find(V: ConstVal, MF: GR.CurMF);
7563 if (!NewReg.isValid()) {
7564 const Function *GVFun =
7565 STI.canUseExtension(E: SPIRV::Extension::SPV_INTEL_function_pointers)
7566 ? dyn_cast<Function>(Val: GV)
7567 : nullptr;
7568 SPIRVTypeInst ResType = GR.getOrCreateSPIRVPointerType(
7569 BaseType: GVType, I,
7570 SC: GVFun ? SPIRV::StorageClass::CodeSectionINTEL
7571 : addressSpaceToStorageClass(AddrSpace: GV->getAddressSpace(), STI));
7572 if (GVFun) {
7573 // References to a function via function pointers generate virtual
7574 // registers without a definition. We will resolve it later, during
7575 // module analysis stage.
7576 Register ResTypeReg = GR.getSPIRVTypeID(SpirvType: ResType);
7577 MachineRegisterInfo *MRI = MIRBuilder.getMRI();
7578 Register FuncVReg =
7579 MRI->createGenericVirtualRegister(Ty: GR.getRegType(SpvType: ResType));
7580 MRI->setRegClass(Reg: FuncVReg, RC: &SPIRV::pIDRegClass);
7581 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: FuncVReg, MF: *GR.CurMF);
7582 MachineInstrBuilder MIB1 =
7583 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUndef))
7584 .addDef(RegNo: FuncVReg)
7585 .addUse(RegNo: ResTypeReg);
7586 MachineInstrBuilder MIB2 =
7587 BuildMI(BB, I, MIMD: I.getDebugLoc(),
7588 MCID: TII.get(Opcode: SPIRV::OpConstantFunctionPointerINTEL))
7589 .addDef(RegNo: ResVReg)
7590 .addUse(RegNo: ResTypeReg)
7591 .addUse(RegNo: FuncVReg);
7592 GR.add(V: ConstVal, MI: MIB2);
7593 // mapping the function pointer to the used Function
7594 GR.recordFunctionPointer(MO: &MIB2.getInstr()->getOperand(i: 2), F: GVFun);
7595 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: ResVReg, MF: *GR.CurMF);
7596 MIB1.constrainAllUses(TII, TRI, RBI);
7597 MIB2.constrainAllUses(TII, TRI, RBI);
7598 return true;
7599 }
7600 MachineInstrBuilder MIB3 =
7601 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpUndef))
7602 .addDef(RegNo: ResVReg)
7603 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType));
7604 GR.add(V: ConstVal, MI: MIB3);
7605 GR.recordFunctionPointer(MO: &MIB3.getInstr()->getOperand(i: 0),
7606 F: cast<Function>(Val: GV));
7607 MIB3.constrainAllUses(TII, TRI, RBI);
7608 return true;
7609 }
7610 assert(NewReg != ResVReg);
7611 return BuildCOPY(DestReg: ResVReg, SrcReg: NewReg, I);
7612 }
7613 auto GlobalVar = cast<GlobalVariable>(Val: GV);
7614 assert(GlobalVar->getName() != "llvm.global.annotations");
7615
7616 // Skip empty declaration for GVs with initializers till we get the decl with
7617 // passed initializer.
7618 if (hasInitializer(GV: GlobalVar) && !Init)
7619 return true;
7620
7621 const std::optional<SPIRV::LinkageType::LinkageType> LnkType =
7622 getSpirvLinkageTypeFor(ST: STI, GV: *GV);
7623
7624 if (LnkType && *LnkType == SPIRV::LinkageType::Import)
7625 Init = nullptr;
7626
7627 const unsigned AddrSpace = GV->getAddressSpace();
7628 SPIRV::StorageClass::StorageClass StorageClass =
7629 addressSpaceToStorageClass(AddrSpace, STI);
7630 SPIRVTypeInst ResType =
7631 GR.getOrCreateSPIRVPointerType(BaseType: GVType, I, SC: StorageClass);
7632 Register Reg = GR.buildGlobalVariable(
7633 Reg: ResVReg, BaseType: ResType, Name: GlobalIdent, GV, Storage: StorageClass, Init,
7634 IsConst: GlobalVar->isConstant(), LinkageType: LnkType, MIRBuilder, IsInstSelector: true);
7635 // TODO: For AMDGCN, we pipe externally_initialized through via
7636 // HostAccessINTEL, with ReadWrite (3) access, which is we then handle during
7637 // reverse translation. We should remove this once SPIR-V gains the ability to
7638 // express the concept.
7639 if (GlobalVar->isExternallyInitialized() &&
7640 STI.getTargetTriple().getVendor() == Triple::AMD) {
7641 constexpr unsigned ReadWriteINTEL = 3u;
7642 buildOpDecorate(Reg, MIRBuilder, Dec: SPIRV::Decoration::HostAccessINTEL,
7643 DecArgs: {ReadWriteINTEL});
7644 MachineInstrBuilder MIB(*MF, --MIRBuilder.getInsertPt());
7645 addStringImm(Str: GV->getName(), MIB);
7646 }
7647 return Reg.isValid();
7648}
7649
7650bool SPIRVInstructionSelector::selectLog10(Register ResVReg,
7651 SPIRVTypeInst ResType,
7652 MachineInstr &I) const {
7653 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std)) {
7654 return selectExtInst(ResVReg, ResType, I, CLInst: CL::log10);
7655 }
7656
7657 // There is no log10 instruction in the GLSL Extended Instruction set, so it
7658 // is implemented as:
7659 // log10(x) = log2(x) * (1 / log2(10))
7660 // = log2(x) * 0.30103
7661
7662 MachineIRBuilder MIRBuilder(I);
7663 MachineBasicBlock &BB = *I.getParent();
7664
7665 // Build log2(x).
7666 Register VarReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7667 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
7668 .addDef(RegNo: VarReg)
7669 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7670 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::GLSL_std_450))
7671 .addImm(Val: GL::Log2)
7672 .add(MO: I.getOperand(i: 1))
7673 .constrainAllUses(TII, TRI, RBI);
7674
7675 // Build 0.30103.
7676 assert(isVectorType(ResType) || ResType.isAnyTypeFloat());
7677 // TODO: Add matrix implementation once supported by the HLSL frontend.
7678 SPIRVTypeInst SpirvScalarType = GR.getScalarOrVectorComponentType(Type: ResType);
7679 // The literal must match the precision of the scalar type, otherwise the
7680 // OpConstant will contain non-zero high-order bits and fail SPIR-V
7681 // validation when the type is narrower than 32 bits (e.g. half).
7682 APFloat ScaleVal(0.30103);
7683 bool LosesInfo;
7684 ScaleVal.convert(
7685 ToSemantics: getZeroFP(LLVMFloatTy: GR.getTypeForSPIRVType(Ty: SpirvScalarType)).getSemantics(),
7686 RM: APFloat::rmNearestTiesToEven, losesInfo: &LosesInfo);
7687 Register ScaleReg = GR.buildConstantFP(Val: ScaleVal, MIRBuilder, SpvType: SpirvScalarType);
7688
7689 // Multiply log2(x) by 0.30103 to get log10(x) result.
7690 auto Opcode =
7691 isVectorType(SPVTy: ResType) ? SPIRV::OpVectorTimesScalar : SPIRV::OpFMulS;
7692 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode))
7693 .addDef(RegNo: ResVReg)
7694 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7695 .addUse(RegNo: VarReg)
7696 .addUse(RegNo: ScaleReg)
7697 .constrainAllUses(TII, TRI, RBI);
7698 return true;
7699}
7700
7701bool SPIRVInstructionSelector::selectFpowi(Register ResVReg,
7702 SPIRVTypeInst ResType,
7703 MachineInstr &I) const {
7704 // On OpenCL targets, pown(gentype x, intn n) maps directly.
7705 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std))
7706 return selectExtInst(ResVReg, ResType, I, CLInst: CL::pown);
7707
7708 // On GLSL (Vulkan) targets, there is no integer-exponent power instruction.
7709 // Lower as: Pow(base, OpConvertSToF(exp)).
7710 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::GLSL_std_450)) {
7711 Register BaseReg = I.getOperand(i: 1).getReg();
7712 Register ExpReg = I.getOperand(i: 2).getReg();
7713 Register FloatExpReg = MRI->createVirtualRegister(RegClass: GR.getRegClass(SpvType: ResType));
7714 if (!selectOpWithSrcs(ResVReg: FloatExpReg, ResType, I, Srcs: {ExpReg},
7715 Opcode: SPIRV::OpConvertSToF))
7716 return false;
7717 return selectExtInst(ResVReg, ResType, I, GLInst: GL::Pow,
7718 /*setMIFlags=*/true, /*useMISrc=*/false,
7719 SrcRegs: {BaseReg, FloatExpReg});
7720 }
7721 return false;
7722}
7723
7724bool SPIRVInstructionSelector::selectModf(Register ResVReg,
7725 SPIRVTypeInst ResType,
7726 MachineInstr &I) const {
7727 // llvm.modf has a single arg --the number to be decomposed-- and returns a
7728 // struct { restype, restype }, while OpenCLLIB::modf has two args --the
7729 // number to be decomposed and a pointer--, returns the fractional part and
7730 // the integral part is stored in the pointer argument. Therefore, we can't
7731 // use directly the OpenCLLIB::modf intrinsic. However, we can do some
7732 // scaffolding to make it work. The idea is to create an alloca instruction
7733 // to get a ptr, pass this ptr to OpenCL::modf, and then load the value
7734 // from this ptr to place it in the struct. llvm.modf returns the fractional
7735 // part as the first element of the result, and the integral part as the
7736 // second element of the result.
7737
7738 // At this point, the return type is not a struct anymore, but rather two
7739 // independent elements of SPIRVResType. We can get each independent element
7740 // from I.getDefs() or I.getOperands().
7741 if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::OpenCL_std)) {
7742 MachineIRBuilder MIRBuilder(I);
7743 SPIRVTypeInst FloatType =
7744 GR.getSPIRVTypeForVReg(VReg: I.getOperand(i: I.getNumExplicitDefs()).getReg());
7745 // Get pointer type for alloca variable.
7746 const SPIRVTypeInst PtrType = GR.getOrCreateSPIRVPointerType(
7747 BaseType: FloatType, MIRBuilder, SC: SPIRV::StorageClass::Function);
7748 // Create new register for the pointer type of alloca variable.
7749 Register PtrTyReg =
7750 MIRBuilder.getMRI()->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
7751 MIRBuilder.getMRI()->setType(
7752 VReg: PtrTyReg,
7753 Ty: LLT::pointer(AddressSpace: storageClassToAddressSpace(SC: SPIRV::StorageClass::Function),
7754 SizeInBits: GR.getPointerSize()));
7755
7756 // Assign SPIR-V type of the pointer type of the alloca variable to the
7757 // new register.
7758 GR.assignSPIRVTypeToVReg(Type: PtrType, VReg: PtrTyReg, MF: MIRBuilder.getMF());
7759 MachineBasicBlock::iterator VarPos = getOpVariableMBBIt(MF&: *I.getMF());
7760 MachineBasicBlock &EntryBB = I.getMF()->front();
7761 const bool IsUntyped =
7762 PtrType->getOpcode() == SPIRV::OpTypeUntypedPointerKHR;
7763 auto AllocaMIB =
7764 BuildMI(BB&: EntryBB, I: VarPos, MIMD: I.getDebugLoc(),
7765 MCID: TII.get(Opcode: IsUntyped ? SPIRV::OpUntypedVariableKHR
7766 : SPIRV::OpVariable))
7767 .addDef(RegNo: PtrTyReg)
7768 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: PtrType))
7769 .addImm(Val: static_cast<uint32_t>(SPIRV::StorageClass::Function));
7770 if (IsUntyped)
7771 AllocaMIB.addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType)); // Data Type
7772 Register Variable = AllocaMIB->getOperand(i: 0).getReg();
7773
7774 MachineBasicBlock &BB = *I.getParent();
7775 // Create the OpenCLLIB::modf instruction.
7776 auto MIB =
7777 BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpExtInst))
7778 .addDef(RegNo: ResVReg)
7779 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: FloatType))
7780 .addImm(Val: static_cast<uint32_t>(SPIRV::InstructionSet::OpenCL_std))
7781 .addImm(Val: CL::modf)
7782 .setMIFlags(I.getFlags())
7783 .add(MO: I.getOperand(i: I.getNumExplicitDefs())) // Floating point value.
7784 .addUse(RegNo: Variable); // Pointer to integral part.
7785 // Assign the integral part stored in the ptr to the second element of the
7786 // result.
7787 Register IntegralPartReg = I.getOperand(i: 1).getReg();
7788 if (IntegralPartReg.isValid() && !MRI->use_nodbg_empty(RegNo: IntegralPartReg)) {
7789 // Load the value from the pointer to integral part.
7790 auto LoadMIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoad))
7791 .addDef(RegNo: IntegralPartReg)
7792 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: FloatType))
7793 .addUse(RegNo: Variable);
7794 LoadMIB.constrainAllUses(TII, TRI, RBI);
7795 }
7796
7797 MIB.constrainAllUses(TII, TRI, RBI);
7798 return true;
7799 } else if (STI.canUseExtInstSet(E: SPIRV::InstructionSet::GLSL_std_450)) {
7800 assert(false && "GLSL::Modf is deprecated.");
7801 // FIXME: GL::Modf is deprecated, use Modfstruct instead.
7802 return false;
7803 }
7804 return false;
7805}
7806
7807// Generate the instructions to load 3-element vector builtin input
7808// IDs/Indices.
7809// Like: GlobalInvocationId, LocalInvocationId, etc....
7810
7811bool SPIRVInstructionSelector::loadVec3BuiltinInputID(
7812 SPIRV::BuiltIn::BuiltIn BuiltInValue, Register ResVReg,
7813 SPIRVTypeInst ResType, MachineInstr &I) const {
7814 MachineIRBuilder MIRBuilder(I);
7815 const SPIRVTypeInst Vec3Ty =
7816 GR.getOrCreateSPIRVVectorType(BaseType: ResType, NumElements: 3, MIRBuilder, EmitIR: false);
7817 const SPIRVTypeInst PtrType = GR.getOrCreateSPIRVPointerType(
7818 BaseType: Vec3Ty, MIRBuilder, SC: SPIRV::StorageClass::Input);
7819
7820 // Create new register for the input ID builtin variable.
7821 Register NewRegister =
7822 MIRBuilder.getMRI()->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
7823 MIRBuilder.getMRI()->setType(VReg: NewRegister, Ty: LLT::pointer(AddressSpace: 0, SizeInBits: 64));
7824 GR.assignSPIRVTypeToVReg(Type: PtrType, VReg: NewRegister, MF: MIRBuilder.getMF());
7825
7826 // Build global variable with the necessary decorations for the input ID
7827 // builtin variable.
7828 Register Variable = GR.buildGlobalVariable(
7829 Reg: NewRegister, BaseType: PtrType, Name: getLinkStringForBuiltIn(BuiltInValue), GV: nullptr,
7830 Storage: SPIRV::StorageClass::Input, Init: nullptr, IsConst: true, LinkageType: std::nullopt, MIRBuilder,
7831 IsInstSelector: false);
7832
7833 // Create new register for loading value.
7834 MachineRegisterInfo *MRI = MIRBuilder.getMRI();
7835 Register LoadedRegister = MRI->createVirtualRegister(RegClass: &SPIRV::iIDRegClass);
7836 MIRBuilder.getMRI()->setType(VReg: LoadedRegister, Ty: LLT::pointer(AddressSpace: 0, SizeInBits: 64));
7837 GR.assignSPIRVTypeToVReg(Type: Vec3Ty, VReg: LoadedRegister, MF: MIRBuilder.getMF());
7838
7839 // Load v3uint value from the global variable.
7840 BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoad))
7841 .addDef(RegNo: LoadedRegister)
7842 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: Vec3Ty))
7843 .addUse(RegNo: Variable);
7844
7845 // Get the input ID index. Expecting operand is a constant immediate value,
7846 // wrapped in a type assignment.
7847 assert(I.getOperand(2).isReg());
7848 const uint32_t ThreadId = foldImm(MO: I.getOperand(i: 2), MRI);
7849
7850 // Extract the input ID from the loaded vector value.
7851 MachineBasicBlock &BB = *I.getParent();
7852 auto MIB = BuildMI(BB, I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpCompositeExtract))
7853 .addDef(RegNo: ResVReg)
7854 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7855 .addUse(RegNo: LoadedRegister)
7856 .addImm(Val: ThreadId);
7857 MIB.constrainAllUses(TII, TRI, RBI);
7858 return true;
7859}
7860
7861// Generate the instructions to load 32-bit integer builtin input IDs/Indices.
7862// Like LocalInvocationIndex
7863bool SPIRVInstructionSelector::loadBuiltinInputID(
7864 SPIRV::BuiltIn::BuiltIn BuiltInValue, Register ResVReg,
7865 SPIRVTypeInst ResType, MachineInstr &I) const {
7866 MachineIRBuilder MIRBuilder(I);
7867 const SPIRVTypeInst PtrType = GR.getOrCreateSPIRVPointerType(
7868 BaseType: ResType, MIRBuilder, SC: SPIRV::StorageClass::Input);
7869
7870 // Create new register for the input ID builtin variable.
7871 Register NewRegister =
7872 MIRBuilder.getMRI()->createVirtualRegister(RegClass: GR.getRegClass(SpvType: PtrType));
7873 MIRBuilder.getMRI()->setType(
7874 VReg: NewRegister,
7875 Ty: LLT::pointer(AddressSpace: storageClassToAddressSpace(SC: SPIRV::StorageClass::Input),
7876 SizeInBits: GR.getPointerSize()));
7877 GR.assignSPIRVTypeToVReg(Type: PtrType, VReg: NewRegister, MF: MIRBuilder.getMF());
7878
7879 // Build global variable with the necessary decorations for the input ID
7880 // builtin variable.
7881 Register Variable = GR.buildGlobalVariable(
7882 Reg: NewRegister, BaseType: PtrType, Name: getLinkStringForBuiltIn(BuiltInValue), GV: nullptr,
7883 Storage: SPIRV::StorageClass::Input, Init: nullptr, IsConst: true, LinkageType: std::nullopt, MIRBuilder,
7884 IsInstSelector: false);
7885
7886 // Load uint value from the global variable.
7887 auto MIB = BuildMI(BB&: *I.getParent(), I, MIMD: I.getDebugLoc(), MCID: TII.get(Opcode: SPIRV::OpLoad))
7888 .addDef(RegNo: ResVReg)
7889 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7890 .addUse(RegNo: Variable);
7891
7892 MIB.constrainAllUses(TII, TRI, RBI);
7893 return true;
7894}
7895
7896SPIRVTypeInst SPIRVInstructionSelector::widenTypeToVec4(SPIRVTypeInst Type,
7897 MachineInstr &I) const {
7898 MachineIRBuilder MIRBuilder(I);
7899 if (!isVectorType(SPVTy: Type))
7900 return GR.getOrCreateSPIRVVectorType(BaseType: Type, NumElements: 4, MIRBuilder, EmitIR: false);
7901
7902 if (GR.getScalarOrVectorComponentCount(Type) == 4)
7903 return Type;
7904
7905 SPIRVTypeInst ScalarType = GR.getScalarOrVectorComponentType(Type);
7906 return GR.getOrCreateSPIRVVectorType(BaseType: ScalarType, NumElements: 4, MIRBuilder, EmitIR: false);
7907}
7908
7909bool SPIRVInstructionSelector::loadHandleBeforePosition(
7910 Register &HandleReg, SPIRVTypeInst ResType, GIntrinsic &HandleDef,
7911 MachineInstr &Pos) const {
7912
7913 assert(HandleDef.getIntrinsicID() ==
7914 Intrinsic::spv_resource_handlefrombinding);
7915 uint32_t Set = foldImm(MO: HandleDef.getOperand(i: 2), MRI);
7916 uint32_t Binding = foldImm(MO: HandleDef.getOperand(i: 3), MRI);
7917 uint32_t ArraySize = foldImm(MO: HandleDef.getOperand(i: 4), MRI);
7918 Register IndexReg = HandleDef.getOperand(i: 5).getReg();
7919 std::string Name =
7920 getStringValueFromReg(Reg: HandleDef.getOperand(i: 6).getReg(), MRI&: *MRI);
7921
7922 bool IsStructuredBuffer = ResType->getOpcode() == SPIRV::OpTypePointer;
7923 MachineIRBuilder MIRBuilder(HandleDef);
7924 SPIRVTypeInst VarType = ResType;
7925 SPIRV::StorageClass::StorageClass SC = SPIRV::StorageClass::UniformConstant;
7926
7927 if (IsStructuredBuffer) {
7928 VarType = GR.getPointeeType(PtrType: ResType);
7929 SC = GR.getPointerStorageClass(Type: ResType);
7930 }
7931
7932 // ArraySize 0 means an unbounded array and we need to set to required
7933 // capability.
7934 if (ArraySize == 0)
7935 MIRBuilder.buildInstr(Opcode: SPIRV::OpCapability)
7936 .addImm(Val: SPIRV::Capability::RuntimeDescriptorArrayEXT);
7937
7938 Register VarReg =
7939 buildPointerToResource(SpirvResType: SPIRVTypeInst(VarType), SC, Set, Binding,
7940 ArraySize, IndexReg, Name, MIRBuilder);
7941
7942 // The handle for the buffer is the pointer to the resource. For an image, the
7943 // handle is the image object. So images get an extra load.
7944 uint32_t LoadOpcode =
7945 IsStructuredBuffer ? SPIRV::OpCopyObject : SPIRV::OpLoad;
7946 GR.assignSPIRVTypeToVReg(Type: ResType, VReg: HandleReg, MF: *Pos.getMF());
7947 BuildMI(BB&: *Pos.getParent(), I&: Pos, MIMD: HandleDef.getDebugLoc(), MCID: TII.get(Opcode: LoadOpcode))
7948 .addDef(RegNo: HandleReg)
7949 .addUse(RegNo: GR.getSPIRVTypeID(SpirvType: ResType))
7950 .addUse(RegNo: VarReg)
7951 .constrainAllUses(TII, TRI, RBI);
7952 return true;
7953}
7954
7955bool SPIRVInstructionSelector::errorIfInstrOutsideShader(
7956 MachineInstr &I) const {
7957 if (!STI.isShader())
7958 return diagnoseUnsupported(
7959 I, Msg: "this instruction is only supported in shaders.");
7960 return true;
7961}
7962
7963namespace llvm {
7964InstructionSelector *
7965createSPIRVInstructionSelector(const SPIRVTargetMachine &TM,
7966 const SPIRVSubtarget &Subtarget,
7967 const RegisterBankInfo &RBI) {
7968 return new SPIRVInstructionSelector(TM, Subtarget, RBI);
7969}
7970} // namespace llvm
7971