spirv-tools: vendor as full-fork recipe (path=source, patches baked)

2026-08-01 04:44:12 +03:00
parent 9695e81f9c
commit f0fa0fd58f
1744 changed files with 714530 additions and 3 deletions
@@ -0,0 +1,232 @@
+// Copyright 2025 Google LLC
+//
+// 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.
+
+#include <array>
+#include <iostream>
+
+#include "gmock/gmock.h"
+#include "source/spirv_target_env.h"
+#include "source/table2.h"
+#include "test/unit_spirv.h"
+
+using ::testing::ContainerEq;
+using ::testing::ValuesIn;
+
+namespace spvtools {
+namespace {
+
+struct OpcodeLookupCase {
+  std::string name;
+  uint32_t opcode;
+  bool expect_pass = true;
+};
+
+std::ostream& operator<<(std::ostream& os, const OpcodeLookupCase& olc) {
+  os << "OLC('" << olc.name << "', " << olc.opcode << ", expect pass? "
+     << olc.expect_pass << ")";
+  return os;
+}
+
+using OpcodeLookupTest = ::testing::TestWithParam<OpcodeLookupCase>;
+
+TEST_P(OpcodeLookupTest, OpcodeLookup_ByName) {
+  const InstructionDesc* desc = nullptr;
+  auto status = LookupOpcode(GetParam().name.data(), &desc);
+  if (GetParam().expect_pass) {
+    EXPECT_EQ(status, SPV_SUCCESS);
+    ASSERT_NE(desc, nullptr);
+    EXPECT_EQ(static_cast<uint32_t>(desc->opcode), GetParam().opcode);
+  } else {
+    EXPECT_NE(status, SPV_SUCCESS);
+    EXPECT_EQ(desc, nullptr);
+  }
+}
+
+TEST_P(OpcodeLookupTest, OpcodeLookup_ByOpcode_Success) {
+  const InstructionDesc* desc = nullptr;
+  if (GetParam().expect_pass) {
+    spv::Op opcode = static_cast<spv::Op>(GetParam().opcode);
+    auto status = LookupOpcode(opcode, &desc);
+    EXPECT_EQ(status, SPV_SUCCESS);
+    ASSERT_NE(desc, nullptr);
+    EXPECT_EQ(desc->opcode, opcode);
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(Samples, OpcodeLookupTest,
+                         ValuesIn(std::vector<OpcodeLookupCase>{
+                             {"Nop", 0},
+                             {"WritePipe", 275},
+                             {"TypeAccelerationStructureKHR", 5341},
+                             {"TypeAccelerationStructureNV", 5341},
+                             {"does not exist", 0, false},
+                             {"CopyLogical", 400},
+                             {"FPGARegINTEL", 5949},
+                             {"SubgroupMatrixMultiplyAccumulateINTEL", 6237},
+                         }));
+
+TEST(OpcodeLookupSingleTest, OpcodeLookup_ByOpcode_Fails) {
+  // This list may need adjusting over time.
+  std::array<uint32_t, 3> bad_opcodes = {{99999, 37737, 110101}};
+  for (auto bad_opcode : bad_opcodes) {
+    const InstructionDesc* desc = nullptr;
+    spv::Op opcode = static_cast<spv::Op>(bad_opcode);
+    auto status = LookupOpcode(opcode, &desc);
+    EXPECT_NE(status, SPV_SUCCESS);
+    ASSERT_EQ(desc, nullptr);
+  }
+}
+
+struct OpcodeLookupEnvCase {
+  std::string name;
+  uint32_t opcode;
+  spv_target_env env = SPV_ENV_UNIVERSAL_1_0;
+  bool expect_pass = true;
+};
+
+std::ostream& operator<<(std::ostream& os, const OpcodeLookupEnvCase& olec) {
+  os << "OLC('" << olec.name << "', " << olec.opcode << ", env "
+     << spvTargetEnvDescription(olec.env) << ", expect pass? "
+     << olec.expect_pass << ")";
+  return os;
+}
+
+using OpcodeLookupEnvTest = ::testing::TestWithParam<OpcodeLookupEnvCase>;
+
+TEST_P(OpcodeLookupEnvTest, OpcodeLookupForEnv_ByName) {
+  const InstructionDesc* desc = nullptr;
+  auto status =
+      LookupOpcodeForEnv(GetParam().env, GetParam().name.data(), &desc);
+  if (GetParam().expect_pass) {
+    EXPECT_EQ(status, SPV_SUCCESS);
+    ASSERT_NE(desc, nullptr);
+    EXPECT_EQ(static_cast<uint32_t>(desc->opcode), GetParam().opcode);
+  } else {
+    EXPECT_NE(status, SPV_SUCCESS);
+    EXPECT_EQ(desc, nullptr);
+  }
+}
+
+TEST_P(OpcodeLookupEnvTest, OpcodeLookupForEnv_ByOpcode) {
+  const InstructionDesc* desc = nullptr;
+  spv::Op opcode = static_cast<spv::Op>(GetParam().opcode);
+  auto status = LookupOpcodeForEnv(GetParam().env, opcode, &desc);
+  if (GetParam().expect_pass) {
+    EXPECT_EQ(status, SPV_SUCCESS);
+    ASSERT_NE(desc, nullptr);
+    EXPECT_EQ(desc->opcode, opcode);
+  } else {
+    // Skip nonsense cases created for the lookup-by-name case.
+    if (GetParam().name != "does not exist") {
+      EXPECT_NE(status, SPV_SUCCESS);
+      EXPECT_EQ(desc, nullptr);
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(Samples, OpcodeLookupEnvTest,
+                         ValuesIn(std::vector<OpcodeLookupEnvCase>{
+                             {"Nop", 0},
+                             {"WritePipe", 275},
+                             {"TypeAccelerationStructureKHR", 5341},
+                             {"TypeAccelerationStructureNV", 5341},
+                             {"does not exist", 0, SPV_ENV_UNIVERSAL_1_0,
+                              false},
+                             {"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_0, false},
+                             {"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_3, false},
+                             {"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_4, true},
+                             {"FPGARegINTEL", 5949},
+                             {"SubgroupMatrixMultiplyAccumulateINTEL", 6237},
+                         }));
+
+TEST(OpcodeLookupExtInstTest, Operands) {
+  // The SPIR-V spec grammar has a single rule for OpExtInst, where the last
+  // item is "sequence of Ids".  SPIRV-Tools handles it differently. It drops
+  // that last item, and instead specifies those operands as operands of the
+  // extended instruction enum, such as 'cos'.
+  // See https://github.com/KhronosGroup/SPIRV-Tools/issues/233
+  // Test the exact sequence of operand types extracted for OpExtInst.
+  const InstructionDesc* desc = nullptr;
+  auto status = LookupOpcode("ExtInst", &desc);
+  EXPECT_EQ(status, SPV_SUCCESS);
+  ASSERT_NE(desc, nullptr);
+
+  EXPECT_EQ(desc->operands_range.count(), 4u);
+
+  auto operands = desc->operands();
+  using vtype = std::vector<spv_operand_type_t>;
+
+  EXPECT_THAT(
+      vtype(operands.begin(), operands.end()),
+      ContainerEq(vtype{SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID,
+                        SPV_OPERAND_TYPE_ID,
+                        SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER}));
+}
+
+// Test printingClass
+
+struct OpcodePrintingClassCase {
+  std::string name;
+  PrintingClass expected;
+};
+
+std::ostream& operator<<(std::ostream& os,
+                         const OpcodePrintingClassCase& opcc) {
+  os << "OPCC('" << opcc.name << "', " << static_cast<int>(opcc.expected)
+     << ")";
+  return os;
+}
+
+using OpcodePrintingClassTest =
+    ::testing::TestWithParam<OpcodePrintingClassCase>;
+
+TEST_P(OpcodePrintingClassTest, OpcodeLookup_ByName) {
+  const InstructionDesc* desc = nullptr;
+  auto status = LookupOpcode(GetParam().name.data(), &desc);
+  EXPECT_EQ(status, SPV_SUCCESS);
+  ASSERT_NE(desc, nullptr);
+  EXPECT_EQ(desc->printingClass, GetParam().expected);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Samples, OpcodePrintingClassTest,
+    ValuesIn(std::vector<OpcodePrintingClassCase>{
+        {"ConstantFunctionPointerINTEL", PrintingClass::k_exclude},
+        {"Nop", PrintingClass::kMiscellaneous},
+        {"SourceContinued", PrintingClass::kDebug},
+        {"Decorate", PrintingClass::kAnnotation},
+        {"Extension", PrintingClass::kExtension},
+        {"MemoryModel", PrintingClass::kMode_Setting},
+        {"Variable", PrintingClass::kMemory},
+        {"CooperativeMatrixPerElementOpNV", PrintingClass::kFunction},
+        {"SampledImage", PrintingClass::kImage},
+        {"ConvertFToU", PrintingClass::kConversion},
+        {"VectorExtractDynamic", PrintingClass::kComposite},
+        {"IAdd", PrintingClass::kArithmetic},
+        {"ShiftRightLogical", PrintingClass::kBit},
+        {"Any", PrintingClass::kRelational_and_Logical},
+        {"DPdx", PrintingClass::kDerivative},
+        {"Branch", PrintingClass::kControl_Flow},
+        {"AtomicLoad", PrintingClass::kAtomic},
+        {"ControlBarrier", PrintingClass::kBarrier},
+        {"GroupAll", PrintingClass::kGroup},
+        {"EnqueueMarker", PrintingClass::kDevice_Side_Enqueue},
+        {"ReadPipe", PrintingClass::kPipe},
+        {"GroupNonUniformElect", PrintingClass::kNon_Uniform},
+        // Skipping "Reserved" because it's probably an
+        // unstable class.
+    }));
+
+}  // namespace
+}  // namespace spvtools