Promote SPV_INTEL_optimization_hints to SPV_KHR_expect_assume

Signed-off-by: Dmitry Sidorov <dmitry.sidorov@intel.com>

Author: MrSidims

include/LLVMSPIRVExtensions.inc

@@ -7,6 +7,7 @@ EXT(SPV_EXT_shader_atomic_float_min_max)
 EXT(SPV_KHR_no_integer_wrap_decoration)
 EXT(SPV_KHR_float_controls)
 EXT(SPV_KHR_linkonce_odr)
+EXT(SPV_KHR_expect_assume)
 EXT(SPV_INTEL_subgroups)
 EXT(SPV_INTEL_media_block_io)
 EXT(SPV_INTEL_device_side_avc_motion_estimation)
@@ -21,7 +22,6 @@ EXT(SPV_INTEL_kernel_attributes)
 EXT(SPV_INTEL_io_pipes)
 EXT(SPV_INTEL_inline_assembly)
 EXT(SPV_INTEL_arbitrary_precision_integers)
-EXT(SPV_INTEL_optimization_hints)
 EXT(SPV_INTEL_float_controls2)
 EXT(SPV_INTEL_vector_compute)
 EXT(SPV_INTEL_fast_composite)

lib/SPIRV/SPIRVReader.cpp

@@ -2432,16 +2432,16 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     return mapValue(BV, Call);
   }
 
-  case internal::OpAssumeTrueINTEL: {
+  case OpAssumeTrueKHR: {
     IRBuilder<> Builder(BB);
-    SPIRVAssumeTrueINTEL *BC = static_cast<SPIRVAssumeTrueINTEL *>(BV);
+    SPIRVAssumeTrueKHR *BC = static_cast<SPIRVAssumeTrueKHR *>(BV);
     Value *Condition = transValue(BC->getCondition(), F, BB);
     return mapValue(BV, Builder.CreateAssumption(Condition));
   }
 
-  case internal::OpExpectINTEL: {
+  case OpExpectKHR: {
     IRBuilder<> Builder(BB);
-    SPIRVExpectINTELInstBase *BC = static_cast<SPIRVExpectINTELInstBase *>(BV);
+    SPIRVExpectKHRInstBase *BC = static_cast<SPIRVExpectKHRInstBase *>(BV);
     Type *RetTy = transType(BC->getType());
     Value *Val = transValue(BC->getOperand(0), F, BB);
     Value *ExpVal = transValue(BC->getOperand(1), F, BB);

lib/SPIRV/SPIRVWriter.cpp

@@ -2362,12 +2362,12 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
   switch (II->getIntrinsicID()) {
   case Intrinsic::assume: {
     // llvm.assume translation is currently supported only within
-    // SPV_INTEL_optimization_hints extension, ignore it otherwise, since it's
+    // SPV_KHR_expect_assume extension, ignore it otherwise, since it's
     // an optimization hint
     if (BM->isAllowedToUseExtension(
-            ExtensionID::SPV_INTEL_optimization_hints)) {
+            ExtensionID::SPV_KHR_expect_assume)) {
       SPIRVValue *Condition = transValue(II->getArgOperand(0), BB);
-      return BM->addAssumeTrueINTELInst(Condition, BB);
+      return BM->addAssumeTrueKHRInst(Condition, BB);
     }
     return nullptr;
   }
@@ -2478,14 +2478,14 @@ SPIRVValue *LLVMToSPIRVBase::transIntrinsicInst(IntrinsicInst *II,
   }
   case Intrinsic::expect: {
     // llvm.expect translation is currently supported only within
-    // SPV_INTEL_optimization_hints extension, replace it with a translated
-    // value of #0 operand otherwise, since it's an optimization hint
+    // SPV_KHR_expect_assume extension, replace it with a translated value of #0
+    // operand otherwise, since it's an optimization hint
     SPIRVValue *Value = transValue(II->getArgOperand(0), BB);
     if (BM->isAllowedToUseExtension(
-            ExtensionID::SPV_INTEL_optimization_hints)) {
+            ExtensionID::SPV_KHR_expect_assume)) {
       SPIRVType *Ty = transType(II->getType());
       SPIRVValue *ExpectedValue = transValue(II->getArgOperand(1), BB);
-      return BM->addExpectINTELInst(Ty, Value, ExpectedValue, BB);
+      return BM->addExpectKHRInst(Ty, Value, ExpectedValue, BB);
     }
     return Value;
   }

lib/SPIRV/libSPIRV/SPIRVInstruction.h

@@ -2864,30 +2864,30 @@ _SPIRV_OP(GenericPtrMemSemantics, true, 4, false)
 _SPIRV_OP(GenericCastToPtrExplicit, true, 5, false, 1)
 #undef _SPIRV_OP
 
-class SPIRVAssumeTrueINTEL : public SPIRVInstruction {
+class SPIRVAssumeTrueKHR : public SPIRVInstruction {
 public:
-  static const Op OC = internal::OpAssumeTrueINTEL;
+  static const Op OC = OpAssumeTrueKHR;
   static const SPIRVWord FixedWordCount = 2;
 
-  SPIRVAssumeTrueINTEL(SPIRVId TheCondition, SPIRVBasicBlock *BB)
+  SPIRVAssumeTrueKHR(SPIRVId TheCondition, SPIRVBasicBlock *BB)
       : SPIRVInstruction(FixedWordCount, OC, BB), ConditionId(TheCondition) {
     validate();
     setHasNoId();
     setHasNoType();
     assert(BB && "Invalid BB");
   }
 
-  SPIRVAssumeTrueINTEL() : SPIRVInstruction(OC), ConditionId(SPIRVID_MAX) {
+  SPIRVAssumeTrueKHR() : SPIRVInstruction(OC), ConditionId(SPIRVID_MAX) {
     setHasNoId();
     setHasNoType();
   }
 
   SPIRVCapVec getRequiredCapability() const override {
-    return getVec(internal::CapabilityOptimizationHintsINTEL);
+    return getVec(CapabilityExpectAssumeKHR);
   }
 
   llvm::Optional<ExtensionID> getRequiredExtension() const override {
-    return ExtensionID::SPV_INTEL_optimization_hints;
+    return ExtensionID::SPV_KHR_expect_assume;
   }
 
   SPIRVValue *getCondition() const { return getValue(ConditionId); }
@@ -2901,22 +2901,21 @@ class SPIRVAssumeTrueINTEL : public SPIRVInstruction {
   SPIRVId ConditionId;
 };
 
-class SPIRVExpectINTELInstBase : public SPIRVInstTemplateBase {
+class SPIRVExpectKHRInstBase : public SPIRVInstTemplateBase {
 protected:
   SPIRVCapVec getRequiredCapability() const override {
-    return getVec(internal::CapabilityOptimizationHintsINTEL);
+    return getVec(CapabilityExpectAssumeKHR);
   }
 
   llvm::Optional<ExtensionID> getRequiredExtension() const override {
-    return ExtensionID::SPV_INTEL_optimization_hints;
+    return ExtensionID::SPV_KHR_expect_assume;
   }
 };
 
-#define _SPIRV_OP_INTERNAL(x, ...)                                             \
-  typedef SPIRVInstTemplate<SPIRVExpectINTELInstBase, internal::Op##x,         \
-                            __VA_ARGS__>                                       \
+#define _SPIRV_OP(x, ...)                                                      \
+  typedef SPIRVInstTemplate<SPIRVExpectKHRInstBase, Op##x, __VA_ARGS__>        \
       SPIRV##x;
-_SPIRV_OP_INTERNAL(ExpectINTEL, true, 5)
+_SPIRV_OP(ExpectKHR, true, 5)
 #undef _SPIRV_OP_INTERNAL
 
 class SPIRVSubgroupShuffleINTELInstBase : public SPIRVInstTemplateBase {

lib/SPIRV/libSPIRV/SPIRVModule.cpp

@@ -441,11 +441,6 @@ class SPIRVModuleImpl : public SPIRVModule {
                                         SPIRVBasicBlock *) override;
   SPIRVInstruction *addSampledImageInst(SPIRVType *, SPIRVValue *, SPIRVValue *,
                                         SPIRVBasicBlock *) override;
-  SPIRVInstruction *addAssumeTrueINTELInst(SPIRVValue *Condition,
-                                           SPIRVBasicBlock *BB) override;
-  SPIRVInstruction *addExpectINTELInst(SPIRVType *ResultTy, SPIRVValue *Value,
-                                       SPIRVValue *ExpectedValue,
-                                       SPIRVBasicBlock *BB) override;
   template <typename AliasingInstType>
   SPIRVEntry *getOrAddMemAliasingINTELInst(std::vector<SPIRVId> Args,
                                            llvm::MDNode *MD);
@@ -455,6 +450,11 @@ class SPIRVModuleImpl : public SPIRVModule {
                                               llvm::MDNode *MD) override;
   SPIRVEntry *getOrAddAliasScopeListDeclINTELInst(std::vector<SPIRVId> Args,
                                                   llvm::MDNode *MD) override;
+  SPIRVInstruction *addAssumeTrueKHRInst(SPIRVValue *Condition,
+                                         SPIRVBasicBlock *BB) override;
+  SPIRVInstruction *addExpectKHRInst(SPIRVType *ResultTy, SPIRVValue *Value,
+                                     SPIRVValue *ExpectedValue,
+                                     SPIRVBasicBlock *BB) override;
 
   virtual SPIRVId getExtInstSetId(SPIRVExtInstSetKind Kind) const override;
 
@@ -1603,17 +1603,17 @@ SPIRVInstruction *SPIRVModuleImpl::addSampledImageInst(SPIRVType *ResultTy,
                         BB);
 }
 
-SPIRVInstruction *SPIRVModuleImpl::addAssumeTrueINTELInst(SPIRVValue *Condition,
+SPIRVInstruction *SPIRVModuleImpl::addAssumeTrueKHRInst(SPIRVValue *Condition,
                                                           SPIRVBasicBlock *BB) {
-  return addInstruction(new SPIRVAssumeTrueINTEL(Condition->getId(), BB), BB);
+  return addInstruction(new SPIRVAssumeTrueKHR(Condition->getId(), BB), BB);
 }
 
-SPIRVInstruction *SPIRVModuleImpl::addExpectINTELInst(SPIRVType *ResultTy,
+SPIRVInstruction *SPIRVModuleImpl::addExpectKHRInst(SPIRVType *ResultTy,
                                                       SPIRVValue *Value,
                                                       SPIRVValue *ExpectedValue,
                                                       SPIRVBasicBlock *BB) {
   return addInstruction(SPIRVInstTemplateBase::create(
-                            internal::OpExpectINTEL, ResultTy, getId(),
+                            OpExpectKHR, ResultTy, getId(),
                             getVec(Value->getId(), ExpectedValue->getId()), BB,
                             this),
                         BB);

lib/SPIRV/libSPIRV/SPIRVModule.h

@@ -449,18 +449,18 @@ class SPIRVModule {
   virtual SPIRVInstruction *addSampledImageInst(SPIRVType *, SPIRVValue *,
                                                 SPIRVValue *,
                                                 SPIRVBasicBlock *) = 0;
-  virtual SPIRVInstruction *addAssumeTrueINTELInst(SPIRVValue *Condition,
-                                                   SPIRVBasicBlock *BB) = 0;
-  virtual SPIRVInstruction *addExpectINTELInst(SPIRVType *ResultTy,
-                                               SPIRVValue *Value,
-                                               SPIRVValue *ExpectedValue,
-                                               SPIRVBasicBlock *BB) = 0;
   virtual SPIRVEntry *getOrAddAliasDomainDeclINTELInst(
       std::vector<SPIRVId> Args, llvm::MDNode *MD) = 0;
   virtual SPIRVEntry *getOrAddAliasScopeDeclINTELInst(
       std::vector<SPIRVId> Args, llvm::MDNode *MD) = 0;
   virtual SPIRVEntry *getOrAddAliasScopeListDeclINTELInst(
       std::vector<SPIRVId> Args, llvm::MDNode *MD) = 0;
+  virtual SPIRVInstruction *addAssumeTrueKHRInst(SPIRVValue *Condition,
+                                                 SPIRVBasicBlock *BB) = 0;
+  virtual SPIRVInstruction *addExpectKHRInst(SPIRVType *ResultTy,
+                                             SPIRVValue *Value,
+                                             SPIRVValue *ExpectedValue,
+                                             SPIRVBasicBlock *BB) = 0;
 
   virtual SPIRVId getExtInstSetId(SPIRVExtInstSetKind Kind) const = 0;
 

lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h

@@ -485,7 +485,7 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
   add(CapabilityAsmINTEL, "AsmINTEL");
   add(CapabilityVectorComputeINTEL, "VectorComputeINTEL");
   add(CapabilityVectorAnyINTEL, "VectorAnyINTEL");
-  add(internal::CapabilityOptimizationHintsINTEL, "OptimizationHintsINTEL");
+  add(CapabilityExpectAssumeKHR, "ExpectAssumeKHR");
   add(CapabilitySubgroupAvcMotionEstimationINTEL,
       "SubgroupAvcMotionEstimationINTEL");
   add(CapabilitySubgroupAvcMotionEstimationIntraINTEL,

lib/SPIRV/libSPIRV/SPIRVOpCodeEnum.h

@@ -345,6 +345,8 @@ _SPIRV_OP(AsmINTEL, 5610)
 _SPIRV_OP(AsmCallINTEL, 5611)
 _SPIRV_OP(AtomicFMinEXT, 5614)
 _SPIRV_OP(AtomicFMaxEXT, 5615)
+_SPIRV_OP(AssumeTrueKHR, 5630)
+_SPIRV_OP(ExpectKHR, 5631)
 _SPIRV_OP(VmeImageINTEL, 5699)
 _SPIRV_OP(TypeVmeImageINTEL, 5700)
 _SPIRV_OP(TypeAvcImePayloadINTEL, 5701)

lib/SPIRV/libSPIRV/SPIRVOpCodeEnumInternal.h

@@ -1,7 +1,5 @@
 #include "spirv_internal.hpp"
 
-_SPIRV_OP_INTERNAL(AssumeTrueINTEL, internal::OpAssumeTrueINTEL)
-_SPIRV_OP_INTERNAL(ExpectINTEL, internal::OpExpectINTEL)
 _SPIRV_OP_INTERNAL(Forward, internal::OpForward)
 _SPIRV_OP_INTERNAL(AliasDomainDeclINTEL, internal::OpAliasDomainDeclINTEL)
 _SPIRV_OP_INTERNAL(AliasScopeDeclINTEL, internal::OpAliasScopeDeclINTEL)

lib/SPIRV/libSPIRV/spirv.hpp

@@ -1026,6 +1026,7 @@ enum Capability {
     CapabilityAtomicFloat16MinMaxEXT = 5616,
     CapabilityVectorComputeINTEL = 5617,
     CapabilityVectorAnyINTEL = 5619,
+    CapabilityExpectAssumeKHR = 5629,
     CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
     CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
     CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
@@ -1544,6 +1545,8 @@ enum Op {
     OpAsmCallINTEL = 5611,
     OpAtomicFMinEXT = 5614,
     OpAtomicFMaxEXT = 5615,
+    OpAssumeTrueKHR = 5630,
+    OpExpectKHR = 5631,
     OpDecorateString = 5632,
     OpDecorateStringGOOGLE = 5632,
     OpMemberDecorateString = 5633,

lib/SPIRV/libSPIRV/spirv_internal.hpp

@@ -35,8 +35,6 @@ enum InternalLinkageType {
 };
 
 enum InternalOp {
-  IOpAssumeTrueINTEL = 5630,
-  IOpExpectINTEL = 5631,
   IOpAliasDomainDeclINTEL = 5911,
   IOpAliasScopeDeclINTEL = 5912,
   IOpAliasScopeListDeclINTEL = 5913,
@@ -50,7 +48,6 @@ enum InternalDecoration {
 };
 
 enum InternalCapability {
-  ICapOptimizationHintsINTEL = 5629,
   ICapMemoryAccessAliasingINTEL = 5910,
   ICapOptNoneINTEL = 6094
 };
@@ -66,8 +63,6 @@ constexpr LinkageType LinkageTypeInternal =
     static_cast<LinkageType>(ILTInternal);
 
 constexpr Op OpForward = static_cast<Op>(IOpForward);
-constexpr Op OpAssumeTrueINTEL = static_cast<Op>(IOpAssumeTrueINTEL);
-constexpr Op OpExpectINTEL = static_cast<Op>(IOpExpectINTEL);
 constexpr Op OpAliasDomainDeclINTEL = static_cast<Op>(IOpAliasDomainDeclINTEL);
 constexpr Op OpAliasScopeDeclINTEL = static_cast<Op>(IOpAliasScopeDeclINTEL);
 constexpr Op OpAliasScopeListDeclINTEL =
@@ -78,8 +73,6 @@ constexpr Decoration DecorationAliasScopeINTEL =
 constexpr Decoration DecorationNoAliasINTEL =
     static_cast<Decoration>(IDecNoAliasINTEL);
 
-constexpr Capability CapabilityOptimizationHintsINTEL =
-    static_cast<Capability>(ICapOptimizationHintsINTEL);
 constexpr Capability CapabilityOptNoneINTEL =
     static_cast<Capability>(ICapOptNoneINTEL);
 constexpr Capability CapabilityMemoryAccessAliasingINTEL =

test/llvm-intrinsics/assume.ll

@@ -1,5 +1,5 @@
 ; RUN: llvm-as %s -o %t.bc
-; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_optimization_hints -o %t.spv
+; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_KHR_expect_assume -o %t.spv
 ; RUN: llvm-spirv %t.spv -to-text -o %t.spt
 ; RUN: FileCheck < %t.spt %s --check-prefix=CHECK-SPIRV
 ; RUN: llvm-spirv -r %t.spv -o %t.bc
@@ -12,20 +12,20 @@
 ; RUN: llvm-spirv -r %t.spv -o %t.bc
 ; RUN: llvm-dis < %t.bc | FileCheck %s --check-prefix=CHECK-LLVM-NO-EXT
 
-; CHECK-SPIRV: Capability OptimizationHintsINTEL
-; CHECK-SPIRV: Extension "SPV_INTEL_optimization_hints"
+; CHECK-SPIRV: Capability ExpectAssumeKHR
+; CHECK-SPIRV: Extension "SPV_KHR_expect_assume"
 ; CHECK-SPIRV: Name [[COMPARE:[0-9]+]] "cmp"
 ; CHECK-SPIRV: INotEqual {{[0-9]+}} [[COMPARE]] {{[0-9]+}} {{[0-9]+}}
-; CHECK-SPIRV: AssumeTrueINTEL [[COMPARE]]
+; CHECK-SPIRV: AssumeTrueKHR [[COMPARE]]
 
 ; CHECK-LLVM: %cmp = icmp ne i32 %0, 0
 ; CHECK-LLVM: call void @llvm.assume(i1 %cmp)
 
-; CHECK-SPIRV-NO-EXT-NOT: Capability OptimizationHintsINTEL
-; CHECK-SPIRV-NO-EXT-NOT: Extension "SPV_INTEL_optimization_hints"
+; CHECK-SPIRV-NO-EXT-NOT: Capability ExpectAssumeKHR
+; CHECK-SPIRV-NO-EXT-NOT: Extension "SPV_KHR_expect_assume"
 ; CHECK-SPIRV-NO-EXT: Name [[COMPARE:[0-9]+]] "cmp"
 ; CHECK-SPIRV-NO-EXT: INotEqual {{[0-9]+}} [[COMPARE]] {{[0-9]+}} {{[0-9]+}}
-; CHECK-SPIRV-NO-EXT-NOT: AssumeTrueINTEL [[COMPARE]]
+; CHECK-SPIRV-NO-EXT-NOT: AssumeTrueKHR [[COMPARE]]
 
 ; CHECK-LLVM-NO-EXT: %cmp = icmp ne i32 %0, 0
 ; CHECK-LLVM-NO-EXT-NOT: call void @llvm.assume(i1 %cmp)

test/llvm-intrinsics/expect.ll

@@ -1,5 +1,5 @@
 ; RUN: llvm-as %s -o %t.bc
-; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_INTEL_optimization_hints -o %t.spv
+; RUN: llvm-spirv %t.bc --spirv-ext=+SPV_KHR_expect_assume -o %t.spv
 ; RUN: llvm-spirv %t.spv -to-text -o %t.spt
 ; RUN: FileCheck < %t.spt %s --check-prefix=CHECK-SPIRV
 ; RUN: llvm-spirv -r %t.spv -o %t.bc
@@ -12,22 +12,22 @@
 ; RUN: llvm-spirv -r %t.spv -o %t.bc
 ; RUN: llvm-dis < %t.bc | FileCheck %s --check-prefix=CHECK-LLVM-NO-EXT
 
-; CHECK-SPIRV: Capability OptimizationHintsINTEL
-; CHECK-SPIRV: Extension "SPV_INTEL_optimization_hints"
+; CHECK-SPIRV: Capability ExpectAssumeKHR
+; CHECK-SPIRV: Extension "SPV_KHR_expect_assume"
 ; CHECK-SPIRV: Name [[FUNPARAM:[0-9]+]] "x.addr"
 ; CHECK-SPIRV: Name [[VALUE1:[0-9]+]] "conv"
 ; CHECK-SPIRV: Name [[VALUE2:[0-9]+]] "conv"
 ; CHECK-SPIRV: TypeInt [[TYPEID:[0-9]+]] 64 0
 ; CHECK-SPIRV: Constant [[TYPEID]] [[EXPVAL1:[0-9]+]] {{[0-9]+}} {{[0-9]+}}
 
 ; CHECK-SPIRV: Function
-; CHECK-SPIRV: ExpectINTEL [[TYPEID]] [[RES1:[0-9]+]] [[VALUE1]] [[EXPVAL1]]
+; CHECK-SPIRV: ExpectKHR [[TYPEID]] [[RES1:[0-9]+]] [[VALUE1]] [[EXPVAL1]]
 ; CHECK-SPIRV: INotEqual {{[0-9]+}} {{[0-9]+}} [[RES1]] {{[0-9]+}}
 
 ; CHECK-SPIRV: Function
 ; CHECK-SPIRV: FunctionCall {{[0-9]+}} [[FUNRES:[0-9]+]] {{[0-9]+}}
 ; CHECK-SPIRV: SConvert [[TYPEID]] [[EXPVAL2:[0-9]+]] [[FUNRES]]
-; CHECK-SPIRV: ExpectINTEL {{[0-9]+}} [[RES2:[0-9]+]] [[VALUE2]] [[EXPVAL2]]
+; CHECK-SPIRV: ExpectKHR {{[0-9]+}} [[RES2:[0-9]+]] [[VALUE2]] [[EXPVAL2]]
 ; CHECK-SPIRV: INotEqual {{[0-9]+}} {{[0-9]+}} [[RES2]] {{[0-9]+}}
 
 ; CHECK-LLVM: define spir_func i32 @_Z12expect_consti{{.*}}
@@ -44,16 +44,16 @@
 ; CHECK-LLVM: %[[RES2:[a-z0-9]+]] = call i64 @llvm.expect.i64(i64 %[[CONV2A]], i64 %[[CONV2B]])
 ; CHECK-LLVM: %{{.*}} = icmp ne i64 %[[RES2]], 0
 
-; CHECK-SPIRV-NO-EXT-NOT: Capability OptimizationHintsINTEL
-; CHECK-SPIRV-NO-EXT-NOT: Extension "SPV_INTEL_optimization_hints"
+; CHECK-SPIRV-NO-EXT-NOT: Capability ExpectAssumeKHR
+; CHECK-SPIRV-NO-EXT-NOT: Extension "SPV_KHR_expect_assume"
 ; CHECK-SPIRV-NO-EXT: Function
-; CHECK-SPIRV-NO-EXT-NOT: ExpectINTEL {{[0-9]+}} {{[0-9]+}} {{[0-9]+}} {{[0-9]+}}
+; CHECK-SPIRV-NO-EXT-NOT: ExpectKHR {{[0-9]+}} {{[0-9]+}} {{[0-9]+}} {{[0-9]+}}
 ; CHECK-SPIRV-NO-EXT: SConvert {{[0-9]+}} [[RES1:[0-9]+]] {{[0-9]+}}
 ; CHECK-SPIRV-NO-EXT: INotEqual {{[0-9]+}} {{[0-9]+}} [[RES1]] {{[0-9]+}}
 
 ; CHECK-SPIRV-NO-EXT: Function
 ; CHECK-SPIRV-NO-EXT: SConvert {{[0-9]+}} [[RES2:[0-9]+]] {{[0-9]+}}
-; CHECK-SPIRV-NO-EXT-NOT: ExpectINTEL {{[0-9]+}} {{[0-9]+}} {{[0-9]+}} {{[0-9]+}}
+; CHECK-SPIRV-NO-EXT-NOT: ExpectKHR {{[0-9]+}} {{[0-9]+}} {{[0-9]+}} {{[0-9]+}}
 ; CHECK-SPIRV-NO-EXT: INotEqual {{[0-9]+}} {{[0-9]+}} [[RES2]] {{[0-9]+}}
 
 ; CHECK-LLVM-NO-EXT: define spir_func i32 @_Z12expect_consti{{.*}}