Skip to content

Commit b1f2327

Browse files
jsjijsji
committed
Revert "SPV_KHR_untyped_pointers - implement OpTypeUntypedPointerKHR (#2687)"
This reverts commit ab78ffb.
1 parent dadd5b3 commit b1f2327

19 files changed

+55
-372
lines changed

‎llvm-spirv/include/LLVMSPIRVExtensions.inc

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@ EXT(SPV_KHR_subgroup_rotate)
1717
EXT(SPV_KHR_non_semantic_info)
1818
EXT(SPV_KHR_shader_clock)
1919
EXT(SPV_KHR_cooperative_matrix)
20-
EXT(SPV_KHR_untyped_pointers)
2120
EXT(SPV_INTEL_subgroups)
2221
EXT(SPV_INTEL_media_block_io)
2322
EXT(SPV_INTEL_device_side_avc_motion_estimation)

‎llvm-spirv/lib/SPIRV/SPIRVReader.cpp

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -357,11 +357,6 @@ Type *SPIRVToLLVM::transType(SPIRVType *T, bool UseTPT) {
357357
return TypedPointerType::get(ElementTy, AS);
358358
return mapType(T, PointerType::get(ElementTy, AS));
359359
}
360-
case OpTypeUntypedPointerKHR: {
361-
const unsigned AS =
362-
SPIRSPIRVAddrSpaceMap::rmap(T->getPointerStorageClass());
363-
return mapType(T, PointerType::get(*Context, AS));
364-
}
365360
case OpTypeVector:
366361
return mapType(T,
367362
FixedVectorType::get(transType(T->getVectorComponentType()),
@@ -565,8 +560,6 @@ std::string SPIRVToLLVM::transTypeToOCLTypeName(SPIRVType *T, bool IsSigned) {
565560
}
566561
return transTypeToOCLTypeName(ET) + "*";
567562
}
568-
case OpTypeUntypedPointerKHR:
569-
return "int*";
570563
case OpTypeVector:
571564
return transTypeToOCLTypeName(T->getVectorComponentType()) +
572565
T->getVectorComponentCount();

‎llvm-spirv/lib/SPIRV/SPIRVWriter.cpp

Lines changed: 14 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -417,8 +417,8 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
417417
// A pointer to image or pipe type in LLVM is translated to a SPIRV
418418
// (non-pointer) image or pipe type.
419419
if (T->isPointerTy()) {
420-
auto AddrSpc = T->getPointerAddressSpace();
421420
auto *ET = Type::getInt8Ty(T->getContext());
421+
auto AddrSpc = T->getPointerAddressSpace();
422422
return transPointerType(ET, AddrSpc);
423423
}
424424

@@ -720,6 +720,7 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
720720
transType(ET)));
721721
}
722722
} else {
723+
SPIRVType *ElementType = transType(ET);
723724
// ET, as a recursive type, may contain exactly the same pointer T, so it
724725
// may happen that after translation of ET we already have translated T,
725726
// added the translated pointer to the SPIR-V module and mapped T to this
@@ -728,17 +729,7 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(Type *ET, unsigned AddrSpc) {
728729
if (Loc != PointeeTypeMap.end()) {
729730
return Loc->second;
730731
}
731-
732-
SPIRVType *ElementType = nullptr;
733-
SPIRVType *TranslatedTy = nullptr;
734-
if (ET->isPointerTy() &&
735-
BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)) {
736-
TranslatedTy = BM->addUntypedPointerKHRType(
737-
SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
738-
} else {
739-
ElementType = transType(ET);
740-
TranslatedTy = transPointerType(ElementType, AddrSpc);
741-
}
732+
SPIRVType *TranslatedTy = transPointerType(ElementType, AddrSpc);
742733
PointeeTypeMap[TypeKey] = TranslatedTy;
743734
return TranslatedTy;
744735
}
@@ -753,16 +744,8 @@ SPIRVType *LLVMToSPIRVBase::transPointerType(SPIRVType *ET, unsigned AddrSpc) {
753744
if (Loc != PointeeTypeMap.end())
754745
return Loc->second;
755746

756-
SPIRVType *TranslatedTy = nullptr;
757-
if (BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers) &&
758-
!(ET->isTypeArray() || ET->isTypeVector() || ET->isTypeImage() ||
759-
ET->isTypeSampler() || ET->isTypePipe())) {
760-
TranslatedTy = BM->addUntypedPointerKHRType(
761-
SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)));
762-
} else {
763-
TranslatedTy = BM->addPointerType(
764-
SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
765-
}
747+
SPIRVType *TranslatedTy = BM->addPointerType(
748+
SPIRSPIRVAddrSpaceMap::map(static_cast<SPIRAddressSpace>(AddrSpc)), ET);
766749
PointeeTypeMap[TypeKey] = TranslatedTy;
767750
return TranslatedTy;
768751
}
@@ -2213,13 +2196,8 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
22132196
MemoryAccessNoAliasINTELMaskMask);
22142197
if (MemoryAccess.front() == 0)
22152198
MemoryAccess.clear();
2216-
return mapValue(
2217-
V,
2218-
BM->addLoadInst(
2219-
transValue(LD->getPointerOperand(), BB), MemoryAccess, BB,
2220-
BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_untyped_pointers)
2221-
? transType(LD->getType())
2222-
: nullptr));
2199+
return mapValue(V, BM->addLoadInst(transValue(LD->getPointerOperand(), BB),
2200+
MemoryAccess, BB));
22232201
}
22242202

22252203
if (BinaryOperator *B = dyn_cast<BinaryOperator>(V)) {
@@ -2429,17 +2407,14 @@ LLVMToSPIRVBase::transValueWithoutDecoration(Value *V, SPIRVBasicBlock *BB,
24292407

24302408
if (auto *Phi = dyn_cast<PHINode>(V)) {
24312409
std::vector<SPIRVValue *> IncomingPairs;
2432-
SPIRVType *Ty = transScavengedType(Phi);
24332410

24342411
for (size_t I = 0, E = Phi->getNumIncomingValues(); I != E; ++I) {
2435-
SPIRVValue *Val = transValue(Phi->getIncomingValue(I), BB, true,
2436-
FuncTransMode::Pointer);
2437-
if (Val->getType() != Ty)
2438-
Val = BM->addUnaryInst(OpBitcast, Ty, Val, BB);
2439-
IncomingPairs.push_back(Val);
2412+
IncomingPairs.push_back(transValue(Phi->getIncomingValue(I), BB, true,
2413+
FuncTransMode::Pointer));
24402414
IncomingPairs.push_back(transValue(Phi->getIncomingBlock(I), nullptr));
24412415
}
2442-
return mapValue(V, BM->addPhiInst(Ty, IncomingPairs, BB));
2416+
return mapValue(V,
2417+
BM->addPhiInst(transScavengedType(Phi), IncomingPairs, BB));
24432418
}
24442419

24452420
if (auto *Ext = dyn_cast<ExtractValueInst>(V)) {
@@ -6696,12 +6671,9 @@ LLVMToSPIRVBase::transBuiltinToInstWithoutDecoration(Op OC, CallInst *CI,
66966671
assert((Pointee == Args[I] || !isa<Function>(Pointee)) &&
66976672
"Illegal use of a function pointer type");
66986673
}
6699-
if (!SPI->isOperandLiteral(I)) {
6700-
SPIRVValue *Val = transValue(Args[I], BB);
6701-
SPArgs.push_back(Val->getId());
6702-
} else {
6703-
SPArgs.push_back(cast<ConstantInt>(Args[I])->getZExtValue());
6704-
}
6674+
SPArgs.push_back(SPI->isOperandLiteral(I)
6675+
? cast<ConstantInt>(Args[I])->getZExtValue()
6676+
: transValue(Args[I], BB)->getId());
67056677
}
67066678
BM->addInstTemplate(SPI, SPArgs, BB, SPRetTy);
67076679
if (!SPRetTy || !SPRetTy->isTypeStruct())

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVInstruction.h

Lines changed: 9 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -568,15 +568,9 @@ class SPIRVStore : public SPIRVInstruction, public SPIRVMemoryAccess {
568568
SPIRVInstruction::validate();
569569
if (getSrc()->isForward() || getDst()->isForward())
570570
return;
571-
assert(
572-
(getValueType(PtrId)
573-
->getPointerElementType()
574-
->isTypeUntypedPointerKHR() ||
575-
// TODO: This check should be removed once we support untyped
576-
// variables.
577-
getValueType(ValId)->isTypeUntypedPointerKHR() ||
578-
getValueType(PtrId)->getPointerElementType() == getValueType(ValId)) &&
579-
"Inconsistent operand types");
571+
assert(getValueType(PtrId)->getPointerElementType() ==
572+
getValueType(ValId) &&
573+
"Inconsistent operand types");
580574
}
581575

582576
private:
@@ -591,12 +585,11 @@ class SPIRVLoad : public SPIRVInstruction, public SPIRVMemoryAccess {
591585
// Complete constructor
592586
SPIRVLoad(SPIRVId TheId, SPIRVId PointerId,
593587
const std::vector<SPIRVWord> &TheMemoryAccess,
594-
SPIRVBasicBlock *TheBB, SPIRVType *TheType = nullptr)
588+
SPIRVBasicBlock *TheBB)
595589
: SPIRVInstruction(
596590
FixedWords + TheMemoryAccess.size(), OpLoad,
597-
TheType ? TheType
598-
: TheBB->getValueType(PointerId)->getPointerElementType(),
599-
TheId, TheBB),
591+
TheBB->getValueType(PointerId)->getPointerElementType(), TheId,
592+
TheBB),
600593
SPIRVMemoryAccess(TheMemoryAccess), PtrId(PointerId),
601594
MemoryAccess(TheMemoryAccess) {
602595
validate();
@@ -626,12 +619,6 @@ class SPIRVLoad : public SPIRVInstruction, public SPIRVMemoryAccess {
626619
void validate() const override {
627620
SPIRVInstruction::validate();
628621
assert((getValue(PtrId)->isForward() ||
629-
getValueType(PtrId)
630-
->getPointerElementType()
631-
->isTypeUntypedPointerKHR() ||
632-
// TODO: This check should be removed once we support untyped
633-
// variables.
634-
Type->isTypeUntypedPointerKHR() ||
635622
Type == getValueType(PtrId)->getPointerElementType()) &&
636623
"Inconsistent types");
637624
}
@@ -2014,8 +2001,7 @@ class SPIRVCompositeExtractBase : public SPIRVInstTemplateBase {
20142001
(void)Composite;
20152002
assert(getValueType(Composite)->isTypeArray() ||
20162003
getValueType(Composite)->isTypeStruct() ||
2017-
getValueType(Composite)->isTypeVector() ||
2018-
getValueType(Composite)->isTypeUntypedPointerKHR());
2004+
getValueType(Composite)->isTypeVector());
20192005
}
20202006
};
20212007

@@ -2041,8 +2027,7 @@ class SPIRVCompositeInsertBase : public SPIRVInstTemplateBase {
20412027
(void)Composite;
20422028
assert(getValueType(Composite)->isTypeArray() ||
20432029
getValueType(Composite)->isTypeStruct() ||
2044-
getValueType(Composite)->isTypeVector() ||
2045-
getValueType(Composite)->isTypeUntypedPointerKHR());
2030+
getValueType(Composite)->isTypeVector());
20462031
assert(Type == getValueType(Composite));
20472032
}
20482033
};
@@ -2389,8 +2374,7 @@ template <Op OC> class SPIRVLifetime : public SPIRVInstruction {
23892374
// Signedness of 1, its sign bit cannot be set.
23902375
if (!(ObjType->getPointerElementType()->isTypeVoid() ||
23912376
// (void *) is i8* in LLVM IR
2392-
ObjType->getPointerElementType()->isTypeInt(8) ||
2393-
ObjType->getPointerElementType()->isTypeUntypedPointerKHR()) ||
2377+
ObjType->getPointerElementType()->isTypeInt(8)) ||
23942378
!Module->hasCapability(CapabilityAddresses))
23952379
assert(Size == 0 && "Size must be 0");
23962380
}

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.cpp

Lines changed: 5 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -252,8 +252,6 @@ class SPIRVModuleImpl : public SPIRVModule {
252252
SPIRVTypeInt *addIntegerType(unsigned BitWidth) override;
253253
SPIRVTypeOpaque *addOpaqueType(const std::string &) override;
254254
SPIRVTypePointer *addPointerType(SPIRVStorageClassKind, SPIRVType *) override;
255-
SPIRVTypeUntypedPointerKHR *
256-
addUntypedPointerKHRType(SPIRVStorageClassKind) override;
257255
SPIRVTypeImage *addImageType(SPIRVType *,
258256
const SPIRVTypeImageDescriptor &) override;
259257
SPIRVTypeImage *addImageType(SPIRVType *, const SPIRVTypeImageDescriptor &,
@@ -355,7 +353,7 @@ class SPIRVModuleImpl : public SPIRVModule {
355353
SPIRVInstruction *addCmpInst(Op, SPIRVType *, SPIRVValue *, SPIRVValue *,
356354
SPIRVBasicBlock *) override;
357355
SPIRVInstruction *addLoadInst(SPIRVValue *, const std::vector<SPIRVWord> &,
358-
SPIRVBasicBlock *, SPIRVType *) override;
356+
SPIRVBasicBlock *) override;
359357
SPIRVInstruction *addPhiInst(SPIRVType *, std::vector<SPIRVValue *>,
360358
SPIRVBasicBlock *) override;
361359
SPIRVInstruction *addCompositeConstructInst(SPIRVType *,
@@ -565,8 +563,6 @@ class SPIRVModuleImpl : public SPIRVModule {
565563
SPIRVUnknownStructFieldMap UnknownStructFieldMap;
566564
SPIRVTypeBool *BoolTy;
567565
SPIRVTypeVoid *VoidTy;
568-
SmallDenseMap<SPIRVStorageClassKind, SPIRVTypeUntypedPointerKHR *>
569-
UntypedPtrTyMap;
570566
SmallDenseMap<unsigned, SPIRVTypeInt *, 4> IntTypeMap;
571567
SmallDenseMap<unsigned, SPIRVTypeFloat *, 4> FloatTypeMap;
572568
SmallDenseMap<std::pair<unsigned, SPIRVType *>, SPIRVTypePointer *, 4>
@@ -1018,17 +1014,6 @@ SPIRVModuleImpl::addPointerType(SPIRVStorageClassKind StorageClass,
10181014
return addType(Ty);
10191015
}
10201016

1021-
SPIRVTypeUntypedPointerKHR *
1022-
SPIRVModuleImpl::addUntypedPointerKHRType(SPIRVStorageClassKind StorageClass) {
1023-
auto Loc = UntypedPtrTyMap.find(StorageClass);
1024-
if (Loc != UntypedPtrTyMap.end())
1025-
return Loc->second;
1026-
1027-
auto *Ty = new SPIRVTypeUntypedPointerKHR(this, getId(), StorageClass);
1028-
UntypedPtrTyMap[StorageClass] = Ty;
1029-
return addType(Ty);
1030-
}
1031-
10321017
SPIRVTypeFunction *SPIRVModuleImpl::addFunctionType(
10331018
SPIRVType *ReturnType, const std::vector<SPIRVType *> &ParameterTypes) {
10341019
return addType(
@@ -1445,10 +1430,9 @@ SPIRVModuleImpl::addInstruction(SPIRVInstruction *Inst, SPIRVBasicBlock *BB,
14451430
SPIRVInstruction *
14461431
SPIRVModuleImpl::addLoadInst(SPIRVValue *Source,
14471432
const std::vector<SPIRVWord> &TheMemoryAccess,
1448-
SPIRVBasicBlock *BB, SPIRVType *TheType) {
1433+
SPIRVBasicBlock *BB) {
14491434
return addInstruction(
1450-
new SPIRVLoad(getId(), Source->getId(), TheMemoryAccess, BB, TheType),
1451-
BB);
1435+
new SPIRVLoad(getId(), Source->getId(), TheMemoryAccess, BB), BB);
14521436
}
14531437

14541438
SPIRVInstruction *
@@ -1941,13 +1925,11 @@ class TopologicalSort {
19411925
// We've found a recursive data type, e.g. a structure having a member
19421926
// which is a pointer to the same structure.
19431927
State = Unvisited; // Forget about it
1944-
if (E->getOpCode() == OpTypePointer ||
1945-
E->getOpCode() == OpTypeUntypedPointerKHR) {
1928+
if (E->getOpCode() == OpTypePointer) {
19461929
// If we have a pointer in the recursive chain, we can break the
19471930
// cyclic dependency by inserting a forward declaration of that
19481931
// pointer.
1949-
SPIRVTypePointerBase<> *Ptr =
1950-
static_cast<SPIRVTypePointerBase<> *>(E);
1932+
SPIRVTypePointer *Ptr = static_cast<SPIRVTypePointer *>(E);
19511933
SPIRVModule *BM = E->getModule();
19521934
ForwardPointerSet.insert(BM->add(new SPIRVTypeForwardPointer(
19531935
BM, Ptr->getId(), Ptr->getPointerStorageClass())));

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.h

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,6 @@ class SPIRVTypeFunction;
7171
class SPIRVTypeInt;
7272
class SPIRVTypeOpaque;
7373
class SPIRVTypePointer;
74-
class SPIRVTypeUntypedPointerKHR;
7574
class SPIRVTypeImage;
7675
class SPIRVTypeSampler;
7776
class SPIRVTypeSampledImage;
@@ -258,8 +257,6 @@ class SPIRVModule {
258257
virtual SPIRVTypeOpaque *addOpaqueType(const std::string &) = 0;
259258
virtual SPIRVTypePointer *addPointerType(SPIRVStorageClassKind,
260259
SPIRVType *) = 0;
261-
virtual SPIRVTypeUntypedPointerKHR *
262-
addUntypedPointerKHRType(SPIRVStorageClassKind) = 0;
263260
virtual SPIRVTypeStruct *openStructType(unsigned, const std::string &) = 0;
264261
virtual SPIRVEntry *addTypeStructContinuedINTEL(unsigned NumMembers) = 0;
265262
virtual void closeStructType(SPIRVTypeStruct *, bool) = 0;
@@ -399,8 +396,7 @@ class SPIRVModule {
399396
SPIRVBasicBlock *BB, SPIRVType *Ty) = 0;
400397
virtual SPIRVInstruction *addLoadInst(SPIRVValue *,
401398
const std::vector<SPIRVWord> &,
402-
SPIRVBasicBlock *,
403-
SPIRVType *TheType = nullptr) = 0;
399+
SPIRVBasicBlock *) = 0;
404400
virtual SPIRVInstruction *addLifetimeInst(Op OC, SPIRVValue *Object,
405401
SPIRVWord Size,
406402
SPIRVBasicBlock *BB) = 0;

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -478,7 +478,6 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
478478
add(CapabilityRoundingModeRTZ, "RoundingModeRTZ");
479479
add(CapabilityRayQueryProvisionalKHR, "RayQueryProvisionalKHR");
480480
add(CapabilityRayQueryKHR, "RayQueryKHR");
481-
add(CapabilityUntypedPointersKHR, "UntypedPointersKHR");
482481
add(CapabilityRayTraversalPrimitiveCullingKHR,
483482
"RayTraversalPrimitiveCullingKHR");
484483
add(CapabilityRayTracingKHR, "RayTracingKHR");

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVOpCode.h

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -227,8 +227,7 @@ inline bool isTypeOpCode(Op OpCode) {
227227
OC == internal::OpTypeJointMatrixINTEL ||
228228
OC == internal::OpTypeJointMatrixINTELv2 ||
229229
OC == OpTypeCooperativeMatrixKHR ||
230-
OC == internal::OpTypeTaskSequenceINTEL ||
231-
OC == OpTypeUntypedPointerKHR;
230+
OC == internal::OpTypeTaskSequenceINTEL;
232231
}
233232

234233
inline bool isSpecConstantOpCode(Op OpCode) {

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVOpCodeEnum.h

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -329,11 +329,13 @@ _SPIRV_OP(GroupNonUniformBitwiseXor, 361)
329329
_SPIRV_OP(GroupNonUniformLogicalAnd, 362)
330330
_SPIRV_OP(GroupNonUniformLogicalOr, 363)
331331
_SPIRV_OP(GroupNonUniformLogicalXor, 364)
332+
_SPIRV_OP(PtrEqual, 401)
333+
_SPIRV_OP(PtrNotEqual, 402)
334+
_SPIRV_OP(PtrDiff, 403)
332335
_SPIRV_OP(CopyLogical, 400)
333336
_SPIRV_OP(PtrEqual, 401)
334337
_SPIRV_OP(PtrNotEqual, 402)
335338
_SPIRV_OP(PtrDiff, 403)
336-
_SPIRV_OP(TypeUntypedPointerKHR, 4417)
337339
_SPIRV_OP(GroupNonUniformRotateKHR, 4431)
338340
_SPIRV_OP(SDotKHR, 4450)
339341
_SPIRV_OP(UDotKHR, 4451)

‎llvm-spirv/lib/SPIRV/libSPIRV/SPIRVType.cpp

Lines changed: 3 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -86,16 +86,12 @@ SPIRVType *SPIRVType::getFunctionReturnType() const {
8686
}
8787

8888
SPIRVType *SPIRVType::getPointerElementType() const {
89-
assert((OpCode == OpTypePointer || OpCode == OpTypeUntypedPointerKHR) &&
90-
"Not a pointer type");
91-
if (OpCode == OpTypeUntypedPointerKHR)
92-
return const_cast<SPIRVType *>(this);
89+
assert(OpCode == OpTypePointer && "Not a pointer type");
9390
return static_cast<const SPIRVTypePointer *>(this)->getElementType();
9491
}
9592

9693
SPIRVStorageClassKind SPIRVType::getPointerStorageClass() const {
97-
assert((OpCode == OpTypePointer || OpCode == OpTypeUntypedPointerKHR) &&
98-
"Not a pointer type");
94+
assert(OpCode == OpTypePointer && "Not a pointer type");
9995
return static_cast<const SPIRVTypePointer *>(this)->getStorageClass();
10096
}
10197

@@ -187,13 +183,7 @@ bool SPIRVType::isTypeInt(unsigned Bits) const {
187183
return isType<SPIRVTypeInt>(this, Bits);
188184
}
189185

190-
bool SPIRVType::isTypePointer() const {
191-
return OpCode == OpTypePointer || OpCode == OpTypeUntypedPointerKHR;
192-
}
193-
194-
bool SPIRVType::isTypeUntypedPointerKHR() const {
195-
return OpCode == OpTypeUntypedPointerKHR;
196-
}
186+
bool SPIRVType::isTypePointer() const { return OpCode == OpTypePointer; }
197187

198188
bool SPIRVType::isTypeOpaque() const { return OpCode == OpTypeOpaque; }
199189

0 commit comments

Comments
 (0)