Add validation support for Intel SPIR-V extensions (KhronosGroup#6232)

pvelesko · web-flow · commit 26fb01b92b00 · 2026-03-18T22:06:29.000Z
This PR adds validation support for three Intel SPIR-V extensions: OpConstantFunctionPointerINTEL: Added validation logic and test coverage ArbitraryPrecisionIntegersINTEL: Added type validation support and tests OpAliasScopeDeclINTEL/OpAliasScopeListDeclINTEL: Added ID validation support and tests Fixes KhronosGroup#6034
diff --git a/source/operand.cpp b/source/operand.cpp
@@ -546,6 +546,11 @@ std::function<bool(unsigned)> spvOperandCanBeForwardDeclaredFunction(
       out = [](unsigned index) { return index == 2; };
       break;
 
+    case spv::Op::OpConstantFunctionPointerINTEL:
+      // The Function parameter.
+      out = [](unsigned index) { return index == 2; };
+      break;
+
     case spv::Op::OpPhi:
       out = [](unsigned index) { return index > 1; };
       break;
diff --git a/source/val/validate_annotation.cpp b/source/val/validate_annotation.cpp
@@ -39,6 +39,8 @@ bool DecorationTakesIdParameters(spv::Decoration type) {
     case spv::Decoration::PayloadNodeBaseIndexAMDX:
     case spv::Decoration::ArrayStrideIdEXT:
     case spv::Decoration::OffsetIdEXT:
+    case spv::Decoration::AliasScopeINTEL:
+    case spv::Decoration::NoAliasINTEL:
       return true;
     default:
       break;
diff --git a/source/val/validate_constants.cpp b/source/val/validate_constants.cpp
@@ -647,6 +647,52 @@ spv_result_t ValidateSpecConstantOp(ValidationState_t& _,
   return SPV_SUCCESS;
 }
 
+spv_result_t ValidateConstantFunctionPointerINTEL(ValidationState_t& _,
+                                                  const Instruction* inst) {
+  const auto result_type = _.FindDef(inst->type_id());
+  // Result Type must be a pointer type
+  if (result_type->opcode() != spv::Op::OpTypePointer &&
+      result_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) {
+    return _.diag(SPV_ERROR_INVALID_ID, inst)
+           << "OpConstantFunctionPointerINTEL Result Type <id> "
+           << _.getIdName(inst->type_id()) << " is not a pointer type";
+  }
+
+  // For typed pointers, check that pointee is a function type
+  const Instruction* pointee_type = nullptr;
+  if (result_type->opcode() == spv::Op::OpTypePointer) {
+    pointee_type = _.FindDef(result_type->GetOperandAs<uint32_t>(2));
+    if (pointee_type->opcode() != spv::Op::OpTypeFunction) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "OpConstantFunctionPointerINTEL Result Type <id> "
+             << _.getIdName(inst->type_id())
+             << " must be a pointer to function type";
+    }
+  }
+
+  // Validate that the function operand refers to an OpFunction
+  const uint32_t function_id = inst->GetOperandAs<uint32_t>(2);
+  const auto function_inst = _.FindDef(function_id);
+  if (function_inst->opcode() != spv::Op::OpFunction) {
+    return _.diag(SPV_ERROR_INVALID_ID, inst)
+           << "OpConstantFunctionPointerINTEL Function operand <id> "
+           << _.getIdName(function_id) << " is not an OpFunction";
+  }
+
+  // For typed pointers, validate that function type matches pointee type
+  if (pointee_type) {
+    const uint32_t function_type_id = function_inst->GetOperandAs<uint32_t>(3);
+    if (function_type_id != pointee_type->id()) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "OpConstantFunctionPointerINTEL Function operand <id> "
+             << _.getIdName(function_id)
+             << " type does not match the pointer's function type";
+    }
+  }
+
+  return SPV_SUCCESS;
+}
+
 }  // namespace
 
 spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) {
@@ -681,6 +727,10 @@ spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) {
     case spv::Op::OpConstantSizeOfEXT:
       if (auto error = ValidateConstantSizeOfEXT(_, inst)) return error;
       break;
+    case spv::Op::OpConstantFunctionPointerINTEL:
+      if (auto error = ValidateConstantFunctionPointerINTEL(_, inst))
+        return error;
+      break;
     default:
       break;
   }
diff --git a/source/val/validate_function.cpp b/source/val/validate_function.cpp
@@ -91,13 +91,13 @@ spv_result_t ValidateFunction(ValidationState_t& _, const Instruction* inst) {
       spv::Op::OpCooperativeMatrixReduceNV,
       spv::Op::OpCooperativeMatrixLoadTensorNV,
       spv::Op::OpConditionalEntryPointINTEL,
-  };
-
+      spv::Op::OpConstantFunctionPointerINTEL};
   for (auto& pair : inst->uses()) {
     const auto* use = pair.first;
     if (std::find(acceptable.begin(), acceptable.end(), use->opcode()) ==
             acceptable.end() &&
-        !use->IsNonSemantic() && !use->IsDebugInfo()) {
+        !use->IsNonSemantic() && !use->IsDebugInfo() &&
+        !spvOpcodeIsDecoration(use->opcode())) {
       return _.diag(SPV_ERROR_INVALID_ID, use)
              << "Invalid use of function result id " << _.getIdName(inst->id())
              << ".";
diff --git a/source/val/validate_id.cpp b/source/val/validate_id.cpp
@@ -154,6 +154,8 @@ bool InstructionRequiresTypeOperand(const Instruction* inst) {
       spv::Op::OpPhi,
       spv::Op::OpUntypedArrayLengthKHR,
       spv::Op::OpAsmINTEL,
+      spv::Op::OpAliasScopeDeclINTEL,
+      spv::Op::OpAliasScopeListDeclINTEL,
   };
   const auto opcode = inst->opcode();
   bool debug_instruction = spvOpcodeIsDebug(opcode) || inst->IsDebugInfo();
diff --git a/source/val/validate_logical_pointers.cpp b/source/val/validate_logical_pointers.cpp
@@ -366,6 +366,8 @@ spv_result_t ValidateLogicalPointerReturns(ValidationState_t& _,
     case spv::Op::OpCopyObject:
     // Core spec bugs
     case spv::Op::OpUndef:
+    // SPV_INTEL_function_pointers
+    case spv::Op::OpConstantFunctionPointerINTEL:
     // SPV_KHR_untyped_pointers
     case spv::Op::OpUntypedAccessChainKHR:
     case spv::Op::OpUntypedInBoundsAccessChainKHR:
diff --git a/source/val/validate_type.cpp b/source/val/validate_type.cpp
@@ -81,6 +81,15 @@ spv_result_t ValidateTypeInt(ValidationState_t& _, const Instruction* inst) {
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << "Using a 64-bit integer type requires the Int64 capability.";
     } else {
+      // Check for SPV_INTEL_arbitrary_precision_integers extension
+      if (_.HasCapability(spv::Capability::ArbitraryPrecisionIntegersINTEL)) {
+        if (num_bits == 0) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << "OpTypeInt has 0 bits, which is not allowed even with "
+                    "ArbitraryPrecisionIntegersINTEL.";
+        }
+        return SPV_SUCCESS;
+      }
       return _.diag(SPV_ERROR_INVALID_DATA, inst)
              << "Invalid number of bits (" << num_bits
              << ") used for OpTypeInt.";
@@ -639,13 +648,20 @@ spv_result_t ValidateTypeFunction(ValidationState_t& _,
   }
 
   // The only valid uses of OpTypeFunction are in an OpFunction, debugging, or
-  // decoration instruction.
+  // decoration instruction, or in OpTypePointer when FunctionPointersINTEL
+  // capability is enabled.
   for (auto& pair : inst->uses()) {
     const auto* use = pair.first;
     if (use->opcode() != spv::Op::OpFunction &&
         use->opcode() != spv::Op::OpAsmINTEL &&
         !spvOpcodeIsDebug(use->opcode()) && !use->IsNonSemantic() &&
         !spvOpcodeIsDecoration(use->opcode())) {
+      // Check if this is OpTypePointer with FunctionPointersINTEL capability
+      if (use->opcode() == spv::Op::OpTypePointer &&
+          _.HasCapability(spv::Capability::FunctionPointersINTEL)) {
+        // Allow OpTypePointer to use function types with this capability
+        continue;
+      }
       return _.diag(SPV_ERROR_INVALID_ID, use)
              << "Invalid use of function type result id "
              << _.getIdName(inst->id()) << ".";
diff --git a/source/val/validation_state.cpp b/source/val/validation_state.cpp
@@ -77,6 +77,12 @@ ModuleLayoutSection InstructionLayoutSection(
     case spv::Op::OpDecorateId:
     case spv::Op::OpDecorateStringGOOGLE:
     case spv::Op::OpMemberDecorateStringGOOGLE:
+    // SPV_INTEL_memory_access_aliasing: alias scope instructions go in the
+    // annotations section so that OpDecorateId can reference them without
+    // requiring a forward reference across layout sections.
+    case spv::Op::OpAliasDomainDeclINTEL:
+    case spv::Op::OpAliasScopeDeclINTEL:
+    case spv::Op::OpAliasScopeListDeclINTEL:
       return kLayoutAnnotations;
     case spv::Op::OpTypeForwardPointer:
     case spv::Op::OpTypeTaskSequenceINTEL:
diff --git a/test/val/CMakeLists.txt b/test/val/CMakeLists.txt
@@ -49,6 +49,7 @@ add_spvtools_unittest(TARGET val_abcde
        val_extension_spv_khr_terminate_invocation_test.cpp
        val_extension_spv_khr_subgroup_rotate_test.cpp
        val_extension_spv_nv_raw_access_chains.cpp
+       val_extension_spv_intel_arbitrary_precision_integers_test.cpp
        val_extension_spv_intel_function_variants.cpp
        val_extension_spv_intel_inline_assembly.cpp
        val_extension_spv_ext_descriptor_heap.cpp
diff --git a/test/val/val_constants_test.cpp b/test/val/val_constants_test.cpp
@@ -1135,6 +1135,28 @@ INSTANTIATE_TEST_SUITE_P(
         //                     "InBoundsPtrAccessChain"),
     }));
 
+TEST_F(ValidateConstant, ForwardConstantFunctionPointerINTEL) {
+  const std::string spirv = R"(
+OpCapability Linkage
+OpCapability Shader
+OpCapability FunctionPointersINTEL
+OpExtension "SPV_INTEL_function_pointers"
+OpMemoryModel Logical Simple
+%void = OpTypeVoid
+%functype = OpTypeFunction %void
+; UniformConstant avoids logical pointer validation conflicts in Function sc
+%ptr_fun = OpTypePointer UniformConstant %functype
+%const_ptr = OpConstantFunctionPointerINTEL %ptr_fun %target_func
+%target_func = OpFunction %void None %functype
+%lbl = OpLabel
+OpReturn
+OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
+}
+
 }  // namespace
 }  // namespace val
 }  // namespace spvtools
diff --git a/test/val/val_extension_spv_intel_arbitrary_precision_integers_test.cpp b/test/val/val_extension_spv_intel_arbitrary_precision_integers_test.cpp
@@ -0,0 +1,178 @@
+// Copyright (c) 2025 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Tests for SPV_INTEL_arbitrary_precision_integers extension
+
+#include <string>
+
+#include "gmock/gmock.h"
+#include "test/val/val_fixtures.h"
+
+namespace spvtools {
+namespace val {
+namespace {
+
+using ::testing::HasSubstr;
+
+using ValidateIntelArbitraryPrecisionIntegers = spvtest::ValidateBase<bool>;
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers,
+       ArbitraryPrecisionIntegerWithoutExtension) {
+  const std::string spirv = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+       %int19 = OpTypeInt 19 1
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("Invalid number of bits (19) used for OpTypeInt"));
+}
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers,
+       ArbitraryPrecisionIntegerWithExtension) {
+  const std::string spirv = R"(
+               OpCapability Shader
+               OpCapability ArbitraryPrecisionIntegersINTEL
+               OpExtension "SPV_INTEL_arbitrary_precision_integers"
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+       %int19 = OpTypeInt 19 1
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers,
+       ArbitraryPrecisionIntegerVariousBitWidths) {
+  const std::string spirv = R"(
+               OpCapability Shader
+               OpCapability ArbitraryPrecisionIntegersINTEL
+               OpExtension "SPV_INTEL_arbitrary_precision_integers"
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+        %int1 = OpTypeInt 1 1
+        %int3 = OpTypeInt 3 0
+        %int7 = OpTypeInt 7 1
+       %int13 = OpTypeInt 13 0
+       %int19 = OpTypeInt 19 1
+       %int33 = OpTypeInt 33 0
+       %int65 = OpTypeInt 65 1
+      %int128 = OpTypeInt 128 0
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers,
+       ArbitraryPrecisionIntegerWithCapabilityOnly) {
+  const std::string spirv = R"(
+               OpCapability Shader
+               OpCapability ArbitraryPrecisionIntegersINTEL
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+       %int19 = OpTypeInt 19 1
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("SPV_INTEL_arbitrary_precision_integers"));
+}
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers, StandardIntegerTypesStillWork) {
+  const std::string spirv = R"(
+               OpCapability Shader
+               OpCapability ArbitraryPrecisionIntegersINTEL
+               OpExtension "SPV_INTEL_arbitrary_precision_integers"
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+       %int32 = OpTypeInt 32 1
+       %uint32 = OpTypeInt 32 0
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
+}
+
+TEST_F(ValidateIntelArbitraryPrecisionIntegers, ZeroBitIntegerRejected) {
+  const std::string spirv = R"(
+               OpCapability Shader
+               OpCapability ArbitraryPrecisionIntegersINTEL
+               OpExtension "SPV_INTEL_arbitrary_precision_integers"
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+       %void = OpTypeVoid
+          %3 = OpTypeFunction %void
+        %int0 = OpTypeInt 0 0
+       %main = OpFunction %void None %3
+          %5 = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+  CompileSuccessfully(spirv);
+  EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
+  EXPECT_THAT(getDiagnosticString(), HasSubstr("OpTypeInt has 0 bits"));
+}
+
+}  // namespace
+}  // namespace val
+}  // namespace spvtools
diff --git a/test/val/val_id_test.cpp b/test/val/val_id_test.cpp
