[NFC] Remove legacy joint matrix instructions

lib/SPIRV/OCLUtil.cpp

@@ -919,8 +919,6 @@ SPIRAddressSpace getOCLOpaqueTypeAddrSpace(Op OpCode) {
   case OpConstantSampler:
   case OpTypeSampler:
     return SPIRV_SAMPLER_T_ADDR_SPACE;
-  case internal::OpTypeJointMatrixINTEL:
-  case internal::OpTypeJointMatrixINTELv2:
   case OpTypeCooperativeMatrixKHR:
   case internal::OpTypeTaskSequenceINTEL:
     return SPIRAS_Global;

lib/SPIRV/SPIRVInternal.h

@@ -317,7 +317,6 @@ const static char ConstantSampler[] = "ConstantSampler";
 const static char PipeStorage[] = "PipeStorage";
 const static char ConstantPipeStorage[] = "ConstantPipeStorage";
 const static char VmeImageINTEL[] = "VmeImageINTEL";
-const static char JointMatrixINTEL[] = "JointMatrixINTEL";
 const static char CooperativeMatrixKHR[] = "CooperativeMatrixKHR";
 const static char BufferSurfaceINTEL[] = "BufferSurfaceINTEL";
 } // namespace kSPIRVTypeName
@@ -972,7 +971,6 @@ template <> inline void SPIRVMap<std::string, Op, SPIRVOpaqueType>::init() {
   _SPIRV_OP(BufferSurfaceINTEL)
   _SPIRV_OP(CooperativeMatrixKHR)
 #undef _SPIRV_OP
-  add("JointMatrixINTEL", internal::OpTypeJointMatrixINTEL);
   add("TaskSequenceINTEL", internal::OpTypeTaskSequenceINTEL);
 }
 

lib/SPIRV/SPIRVReader.cpp

@@ -475,31 +475,6 @@ Type *SPIRVToLLVM::transType(SPIRVType *T, bool UseTPT) {
     }
     return mapType(T, Ty);
   }
-  case internal::OpTypeJointMatrixINTEL: {
-    auto *MT = static_cast<SPIRVTypeJointMatrixINTEL *>(T);
-    auto R = static_cast<SPIRVConstant *>(MT->getRows())->getZExtIntValue();
-    auto C = static_cast<SPIRVConstant *>(MT->getColumns())->getZExtIntValue();
-    std::vector<unsigned> Params = {(unsigned)R, (unsigned)C};
-    if (auto *Layout = MT->getLayout())
-      Params.push_back(static_cast<SPIRVConstant *>(Layout)->getZExtIntValue());
-    Params.push_back(
-        static_cast<SPIRVConstant *>(MT->getScope())->getZExtIntValue());
-    if (auto *Use = MT->getUse())
-      Params.push_back(static_cast<SPIRVConstant *>(Use)->getZExtIntValue());
-    auto *CTI = MT->getComponentTypeInterpretation();
-    if (!CTI)
-      return mapType(
-          T, llvm::TargetExtType::get(*Context, "spirv.JointMatrixINTEL",
-                                      transType(MT->getCompType()), Params));
-    const unsigned CTIValue =
-        static_cast<SPIRVConstant *>(CTI)->getZExtIntValue();
-    assert(CTIValue <= internal::InternalJointMatrixCTI::PackedInt4 &&
-           "Unknown matrix component type interpretation");
-    Params.push_back(CTIValue);
-    return mapType(
-        T, llvm::TargetExtType::get(*Context, "spirv.JointMatrixINTEL",
-                                    transType(MT->getCompType()), Params));
-  }
   case OpTypeCooperativeMatrixKHR: {
     auto *MT = static_cast<SPIRVTypeCooperativeMatrixKHR *>(T);
     unsigned Scope =
@@ -2561,7 +2536,6 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
       auto *Load = new LoadInst(ST, Alloca, "load", false, BB);
       return mapValue(BV, Load);
     }
-    case internal::OpTypeJointMatrixINTEL:
     case OpTypeCooperativeMatrixKHR:
     case internal::OpTypeTaskSequenceINTEL:
       return mapValue(BV, transSPIRVBuiltinFromInst(CC, BB));
@@ -2592,9 +2566,6 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
   case OpVectorExtractDynamic: {
     auto *VED = static_cast<SPIRVVectorExtractDynamic *>(BV);
     SPIRVValue *Vec = VED->getVector();
-    if (Vec->getType()->getOpCode() == internal::OpTypeJointMatrixINTEL) {
-      return mapValue(BV, transSPIRVBuiltinFromInst(VED, BB));
-    }
     return mapValue(
         BV, ExtractElementInst::Create(transValue(Vec, F, BB),
                                        transValue(VED->getIndex(), F, BB),
@@ -2625,9 +2596,6 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
   case OpVectorInsertDynamic: {
     auto *VID = static_cast<SPIRVVectorInsertDynamic *>(BV);
     SPIRVValue *Vec = VID->getVector();
-    if (Vec->getType()->getOpCode() == internal::OpTypeJointMatrixINTEL) {
-      return mapValue(BV, transSPIRVBuiltinFromInst(VID, BB));
-    }
     return mapValue(
         BV, InsertElementInst::Create(
                 transValue(Vec, F, BB), transValue(VID->getComponent(), F, BB),
@@ -3913,7 +3881,6 @@ Instruction *SPIRVToLLVM::transSPIRVBuiltinFromInst(SPIRVInstruction *BI,
   case OpUDotAccSatKHR:
   case OpSUDotAccSatKHR:
   case OpReadClockKHR:
-  case internal::OpJointMatrixLoadINTEL:
   case OpCooperativeMatrixLoadKHR:
   case internal::OpCooperativeMatrixLoadCheckedINTEL:
   case internal::OpCooperativeMatrixLoadOffsetINTEL:

lib/SPIRV/SPIRVWriter.cpp

@@ -592,18 +592,6 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
         ArrayRef<unsigned> Ops = TargetTy->int_params();
         return mapType(T, BM->addBufferSurfaceINTELType(CastAccess(Ops[0])));
       }
-      case internal::OpTypeJointMatrixINTEL: {
-        // The expected representation is:
-        // target("spirv.JointMatrixINTEL", %element_type, %rows%, %cols%,
-        //        %layout%, %scope%, %use%,
-        //        (optional) %element_type_interpretation%)
-        auto *ElemTy = transType(TargetTy->getTypeParameter(0));
-        ArrayRef<unsigned> Ops = TargetTy->int_params();
-        std::vector<SPIRVValue *> Args;
-        for (const auto &Op : Ops)
-          Args.emplace_back(transConstant(getUInt32(M, Op)));
-        return mapType(T, BM->addJointMatrixINTELType(ElemTy, Args));
-      }
       case OpTypeCooperativeMatrixKHR: {
         // The expected representation is:
         // target("spirv.CooperativeMatrixKHR", %element_type, %scope%, %rows%,

lib/SPIRV/libSPIRV/SPIRVEntry.cpp

@@ -86,10 +86,6 @@ SPIRVEntry *SPIRVEntry::create(Op OpCode) {
   static const OpToFactoryMapTy OpToFactoryMap(std::begin(Table),
                                                std::end(Table));
 
-  // TODO: To remove this when we make a switch to new version
-  if (OpCode == internal::OpTypeJointMatrixINTELv2)
-    OpCode = internal::OpTypeJointMatrixINTEL;
-
   // OpAtomicCompareExchangeWeak is removed starting from SPIR-V 1.4
   if (OpCode == OpAtomicCompareExchangeWeak)
     OpCode = OpAtomicCompareExchange;

lib/SPIRV/libSPIRV/SPIRVEnum.h

@@ -206,15 +206,11 @@ template <> inline void SPIRVMap<SPIRVCapabilityKind, SPIRVCapVec>::init() {
   ADD_VEC_INIT(CapabilitySubgroupAvcMotionEstimationChromaINTEL,
                {CapabilitySubgroupAvcMotionEstimationIntraINTEL});
   ADD_VEC_INIT(internal::CapabilityJointMatrixWIInstructionsINTEL,
-               {internal::CapabilityJointMatrixINTEL});
-  ADD_VEC_INIT(internal::CapabilityJointMatrixTF32ComponentTypeINTEL,
-               {internal::CapabilityJointMatrixINTEL});
-  ADD_VEC_INIT(internal::CapabilityJointMatrixBF16ComponentTypeINTEL,
-               {internal::CapabilityJointMatrixINTEL});
-  ADD_VEC_INIT(internal::CapabilityJointMatrixPackedInt2ComponentTypeINTEL,
-               {internal::CapabilityJointMatrixINTEL});
-  ADD_VEC_INIT(internal::CapabilityJointMatrixPackedInt4ComponentTypeINTEL,
-               {internal::CapabilityJointMatrixINTEL});
+               {CapabilityCooperativeMatrixKHR});
+  ADD_VEC_INIT(internal::CapabilityCooperativeMatrixTF32ComponentTypeINTEL,
+               {CapabilityCooperativeMatrixKHR});
+  ADD_VEC_INIT(internal::CapabilityCooperativeMatrixBFloat16ComponentTypeINTEL,
+               {CapabilityCooperativeMatrixKHR});
   ADD_VEC_INIT(internal::CapabilityCooperativeMatrixPrefetchINTEL,
                {CapabilityCooperativeMatrixKHR});
   ADD_VEC_INIT(internal::CapabilityCooperativeMatrixInvocationInstructionsINTEL,

lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -2127,8 +2127,6 @@ class SPIRVCompositeConstruct : public SPIRVInstruction {
       break;
     case OpTypeArray:
     case OpTypeStruct:
-    case internal::OpTypeJointMatrixINTEL:
-    case internal::OpTypeJointMatrixINTELv2:
     case OpTypeCooperativeMatrixKHR:
       break;
     default:
@@ -2388,8 +2386,7 @@ class SPIRVVectorExtractDynamic : public SPIRVInstruction {
     SPIRVInstruction::validate();
     if (getValue(VectorId)->isForward())
       return;
-    assert(getValueType(VectorId)->isTypeVector() ||
-           getValueType(VectorId)->isTypeJointMatrixINTEL());
+    assert(getValueType(VectorId)->isTypeVector());
   }
   SPIRVId VectorId;
   SPIRVId IndexId;
@@ -2426,8 +2423,7 @@ class SPIRVVectorInsertDynamic : public SPIRVInstruction {
     SPIRVInstruction::validate();
     if (getValue(VectorId)->isForward())
       return;
-    assert(getValueType(VectorId)->isTypeVector() ||
-           getValueType(VectorId)->isTypeJointMatrixINTEL());
+    assert(getValueType(VectorId)->isTypeVector());
   }
   SPIRVId VectorId;
   SPIRVId IndexId;
@@ -3605,8 +3601,9 @@ class SPIRVBfloat16ConversionINTELInstBase : public SPIRVUnaryInst<OC> {
   SPIRVCapVec getRequiredCapability() const override {
     SPIRVType *ResCompTy = this->getType();
     if (ResCompTy->isTypeCooperativeMatrixKHR())
-      return getVec(CapabilityBFloat16ConversionINTEL,
-                    internal::CapabilityJointMatrixBF16ComponentTypeINTEL);
+      return getVec(
+          CapabilityBFloat16ConversionINTEL,
+          internal::CapabilityCooperativeMatrixBFloat16ComponentTypeINTEL);
     return getVec(CapabilityBFloat16ConversionINTEL);
   }
 
@@ -3701,26 +3698,6 @@ class SPIRVJointMatrixINTELInstBase : public SPIRVInstTemplateBase {
   }
 };
 
-class SPIRVJointMatrixINTELInst : public SPIRVJointMatrixINTELInstBase {
-  SPIRVCapVec getRequiredCapability() const override {
-    return getVec(internal::CapabilityJointMatrixINTEL);
-  }
-};
-
-#define _SPIRV_OP(x, ...)                                                      \
-  typedef SPIRVInstTemplate<SPIRVJointMatrixINTELInst, internal::Op##x##INTEL, \
-                            __VA_ARGS__>                                       \
-      SPIRV##x##INTEL;
-_SPIRV_OP(JointMatrixLoad, true, 6, true)
-_SPIRV_OP(JointMatrixStore, false, 5, true)
-_SPIRV_OP(JointMatrixMad, true, 6, true)
-_SPIRV_OP(JointMatrixSUMad, true, 6, true)
-_SPIRV_OP(JointMatrixUSMad, true, 6, true)
-_SPIRV_OP(JointMatrixUUMad, true, 6, true)
-// TODO: move to SPIRVJointMatrixINTELWorkItemInst
-_SPIRV_OP(JointMatrixWorkItemLength, true, 4)
-#undef _SPIRV_OP
-
 class SPIRVJointMatrixINTELWorkItemInst : public SPIRVJointMatrixINTELInstBase {
 protected:
   SPIRVCapVec getRequiredCapability() const override {
@@ -4032,8 +4009,9 @@ class SPIRVTensorFloat32RoundingINTELInstBase : public SPIRVUnaryInst<OC> {
   SPIRVCapVec getRequiredCapability() const override {
     SPIRVType *ResCompTy = this->getType();
     if (ResCompTy->isTypeCooperativeMatrixKHR())
-      return getVec(CapabilityTensorFloat32RoundingINTEL,
-                    internal::CapabilityJointMatrixTF32ComponentTypeINTEL);
+      return getVec(
+          CapabilityTensorFloat32RoundingINTEL,
+          internal::CapabilityCooperativeMatrixTF32ComponentTypeINTEL);
     return getVec(CapabilityTensorFloat32RoundingINTEL);
   }
 

lib/SPIRV/libSPIRV/SPIRVModule.cpp

@@ -328,8 +328,6 @@ class SPIRVModuleImpl : public SPIRVModule {
   SPIRVEntry *addTypeStructContinuedINTEL(unsigned NumMembers) override;
   void closeStructType(SPIRVTypeStruct *T, bool) override;
   SPIRVTypeVector *addVectorType(SPIRVType *, SPIRVWord) override;
-  SPIRVTypeJointMatrixINTEL *
-  addJointMatrixINTELType(SPIRVType *, std::vector<SPIRVValue *>) override;
   SPIRVTypeCooperativeMatrixKHR *
   addCooperativeMatrixKHRType(SPIRVType *, std::vector<SPIRVValue *>) override;
   SPIRVTypeTaskSequenceINTEL *addTaskSequenceINTELType() override;
@@ -1173,12 +1171,6 @@ SPIRVTypeVector *SPIRVModuleImpl::addVectorType(SPIRVType *CompType,
   return addType(Ty);
 }
 
-SPIRVTypeJointMatrixINTEL *
-SPIRVModuleImpl::addJointMatrixINTELType(SPIRVType *CompType,
-                                         std::vector<SPIRVValue *> Args) {
-  return addType(new SPIRVTypeJointMatrixINTEL(this, getId(), CompType, Args));
-}
-
 SPIRVTypeCooperativeMatrixKHR *
 SPIRVModuleImpl::addCooperativeMatrixKHRType(SPIRVType *CompType,
                                              std::vector<SPIRVValue *> Args) {

lib/SPIRV/libSPIRV/SPIRVModule.h

@@ -289,8 +289,6 @@ class SPIRVModule {
   virtual SPIRVEntry *addTypeStructContinuedINTEL(unsigned NumMembers) = 0;
   virtual void closeStructType(SPIRVTypeStruct *, bool) = 0;
   virtual SPIRVTypeVector *addVectorType(SPIRVType *, SPIRVWord) = 0;
-  virtual SPIRVTypeJointMatrixINTEL *
-  addJointMatrixINTELType(SPIRVType *, std::vector<SPIRVValue *>) = 0;
   virtual SPIRVTypeCooperativeMatrixKHR *
   addCooperativeMatrixKHRType(SPIRVType *, std::vector<SPIRVValue *>) = 0;
   virtual SPIRVTypeTaskSequenceINTEL *addTaskSequenceINTELType() = 0;

lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

@@ -657,23 +657,18 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
   add(CapabilityTernaryBitwiseFunctionINTEL, "TernaryBitwiseFunctionINTEL");
   // From spirv_internal.hpp
   add(internal::CapabilityTokenTypeINTEL, "TokenTypeINTEL");
-  add(internal::CapabilityJointMatrixINTEL, "JointMatrixINTEL");
   add(internal::CapabilityHWThreadQueryINTEL, "HWThreadQueryINTEL");
   add(internal::CapabilityGlobalVariableDecorationsINTEL,
       "GlobalVariableDecorationsINTEL");
   add(internal::CapabilityMaskedGatherScatterINTEL, "MaskedGatherScatterINTEL");
   add(CapabilityTensorFloat32RoundingINTEL,
       "TensorFloat32RoundingINTEL");
   add(internal::CapabilityJointMatrixWIInstructionsINTEL,
-      "JointMatrixWIInstructionsINTEL");
-  add(internal::CapabilityJointMatrixTF32ComponentTypeINTEL,
-      "JointMatrixTF32ComponentTypeINTEL");
-  add(internal::CapabilityJointMatrixBF16ComponentTypeINTEL,
-      "JointMatrixBF16ComponentTypeINTEL");
-  add(internal::CapabilityJointMatrixPackedInt2ComponentTypeINTEL,
-      "JointMatrixPackedInt2ComponentTypeINTEL");
-  add(internal::CapabilityJointMatrixPackedInt4ComponentTypeINTEL,
-      "JointMatrixPackedInt4ComponentTypeINTEL");
+      "CooperativeMatrixInvocationInstructionsINTEL");
+  add(internal::CapabilityCooperativeMatrixTF32ComponentTypeINTEL,
+      "CooperativeMatrixTF32ComponentTypeINTEL");
+  add(internal::CapabilityCooperativeMatrixBFloat16ComponentTypeINTEL,
+      "CooperativeMatrixBFloat16ComponentTypeINTEL");
   add(internal::CapabilityCooperativeMatrixPrefetchINTEL,
       "CooperativeMatrixPrefetchINTEL");
   add(internal::CapabilityCooperativeMatrixInvocationInstructionsINTEL,

lib/SPIRV/libSPIRV/SPIRVOpCode.h

@@ -251,8 +251,6 @@ inline bool isTypeOpCode(Op OpCode) {
   return (OpTypeVoid <= OC && OC <= OpTypePipe) || OC == OpTypePipeStorage ||
          isSubgroupAvcINTELTypeOpCode(OpCode) || OC == OpTypeVmeImageINTEL ||
          isVCOpCode(OpCode) || OC == internal::OpTypeTokenINTEL ||
-         OC == internal::OpTypeJointMatrixINTEL ||
-         OC == internal::OpTypeJointMatrixINTELv2 ||
          OC == OpTypeCooperativeMatrixKHR ||
          OC == internal::OpTypeTaskSequenceINTEL ||
          OC == OpTypeUntypedPointerKHR;

lib/SPIRV/libSPIRV/SPIRVOpCodeEnumInternal.h

@@ -2,15 +2,6 @@
 
 _SPIRV_OP_INTERNAL(Forward, internal::OpForward)
 _SPIRV_OP_INTERNAL(TypeTokenINTEL, internal::OpTypeTokenINTEL)
-_SPIRV_OP_INTERNAL(TypeJointMatrixINTEL, internal::OpTypeJointMatrixINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixLoadINTEL, internal::OpJointMatrixLoadINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixStoreINTEL, internal::OpJointMatrixStoreINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixMadINTEL, internal::OpJointMatrixMadINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixSUMadINTEL, internal::OpJointMatrixSUMadINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixUSMadINTEL, internal::OpJointMatrixUSMadINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixUUMadINTEL, internal::OpJointMatrixUUMadINTEL)
-_SPIRV_OP_INTERNAL(JointMatrixWorkItemLengthINTEL,
-                   internal::OpJointMatrixWorkItemLengthINTEL)
 _SPIRV_OP_INTERNAL(JointMatrixGetElementCoordINTEL,
                    internal::OpJointMatrixGetElementCoordINTEL)
 _SPIRV_OP_INTERNAL(CooperativeMatrixPrefetchINTEL,

lib/SPIRV/libSPIRV/SPIRVType.cpp

@@ -117,12 +117,11 @@ SPIRVWord SPIRVType::getVectorComponentCount() const {
 SPIRVType *SPIRVType::getVectorComponentType() const {
   if (OpCode == OpTypeVector)
     return static_cast<const SPIRVTypeVector *>(this)->getComponentType();
-  if (OpCode == internal::OpTypeJointMatrixINTEL)
-    return static_cast<const SPIRVTypeJointMatrixINTEL *>(this)->getCompType();
   if (OpCode == OpTypeCooperativeMatrixKHR)
     return static_cast<const SPIRVTypeCooperativeMatrixKHR *>(this)
         ->getCompType();
-  assert(0 && "getVectorComponentType(): Not a vector or joint matrix type");
+  assert(0 &&
+         "getVectorComponentType(): Not a vector or cooperative matrix type");
   return nullptr;
 }
 
@@ -163,7 +162,7 @@ bool SPIRVType::isTypeBool() const { return OpCode == OpTypeBool; }
 
 bool SPIRVType::isTypeComposite() const {
   return isTypeVector() || isTypeArray() || isTypeStruct() ||
-         isTypeJointMatrixINTEL() || isTypeCooperativeMatrixKHR();
+         isTypeCooperativeMatrixKHR();
 }
 
 bool SPIRVType::isTypeFloat(unsigned Bits,
@@ -222,10 +221,6 @@ bool SPIRVType::isTypeStruct() const { return OpCode == OpTypeStruct; }
 
 bool SPIRVType::isTypeVector() const { return OpCode == OpTypeVector; }
 
-bool SPIRVType::isTypeJointMatrixINTEL() const {
-  return OpCode == internal::OpTypeJointMatrixINTEL ||
-         OpCode == internal::OpTypeJointMatrixINTELv2;
-}
 
 bool SPIRVType::isTypeCooperativeMatrixKHR() const {
   return OpCode == OpTypeCooperativeMatrixKHR;
@@ -276,8 +271,7 @@ bool SPIRVType::isSPIRVOpaqueType() const {
   return isTypeDeviceEvent() || isTypeEvent() || isTypeImage() ||
          isTypePipe() || isTypeReserveId() || isTypeSampler() ||
          isTypeSampledImage() || isTypePipeStorage() ||
-         isTypeCooperativeMatrixKHR() || isTypeJointMatrixINTEL() ||
-         isTypeTaskSequenceINTEL();
+         isTypeCooperativeMatrixKHR() || isTypeTaskSequenceINTEL();
 }
 
 bool SPIRVTypeStruct::isPacked() const {
@@ -318,33 +312,6 @@ void SPIRVTypeForwardPointer::decode(std::istream &I) {
   Decoder >> PointerId >> SC;
 }
 
-SPIRVTypeJointMatrixINTEL::SPIRVTypeJointMatrixINTEL(
-    SPIRVModule *M, SPIRVId TheId, Op OC, SPIRVType *CompType,
-    std::vector<SPIRVValue *> Args)
-    : SPIRVType(M, FixedWC + Args.size(), OC, TheId), CompType(CompType),
-      Args(std::move(Args)) {}
-
-SPIRVTypeJointMatrixINTEL::SPIRVTypeJointMatrixINTEL(
-    SPIRVModule *M, SPIRVId TheId, SPIRVType *CompType,
-    std::vector<SPIRVValue *> Args)
-    : SPIRVType(M, FixedWC + Args.size(), internal::OpTypeJointMatrixINTEL,
-                TheId),
-      CompType(CompType), Args(std::move(Args)) {}
-
-SPIRVTypeJointMatrixINTEL::SPIRVTypeJointMatrixINTEL()
-    : SPIRVType(internal::OpTypeJointMatrixINTEL), CompType(nullptr),
-      Args({nullptr, nullptr, nullptr, nullptr}) {}
-
-void SPIRVTypeJointMatrixINTEL::encode(spv_ostream &O) const {
-  auto Encoder = getEncoder(O);
-  Encoder << Id << CompType << Args;
-}
-
-void SPIRVTypeJointMatrixINTEL::decode(std::istream &I) {
-  auto Decoder = getDecoder(I);
-  Decoder >> Id >> CompType >> Args;
-}
-
 SPIRVTypeCooperativeMatrixKHR::SPIRVTypeCooperativeMatrixKHR(
     SPIRVModule *M, SPIRVId TheId, SPIRVType *CompType,
     std::vector<SPIRVValue *> Args)