mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

   1 //===- SerializationTest.cpp - SPIR-V Serialization Tests -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains corner case tests for the SPIR-V serializer that are not
  10 // covered by normal serialization and deserialization roundtripping.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "mlir/Target/SPIRV/Serialization.h"
  15 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
  16 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
  17 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
  18 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
  19 #include "mlir/IR/Builders.h"
  20 #include "mlir/IR/Location.h"
  21 #include "mlir/IR/MLIRContext.h"
  22 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
  23 #include "llvm/ADT/DenseSet.h"
  24 #include "llvm/ADT/STLExtras.h"
  25 #include "llvm/ADT/Sequence.h"
  26 #include "llvm/ADT/SmallVector.h"
  27 #include "llvm/ADT/StringRef.h"
  28 #include "gmock/gmock.h"
  29
  30 using namespace mlir;
  31
  32 //===----------------------------------------------------------------------===//
  33 // Test Fixture
  34 //===----------------------------------------------------------------------===//
  35
  36 class SerializationTest : public ::testing::Test {
  37 protected:
  38   SerializationTest() {
  39     context.getOrLoadDialect<mlir::spirv::SPIRVDialect>();
  40     initModuleOp();
  41   }
  42
  43   /// Initializes an empty SPIR-V module op.
  44   void initModuleOp() {
  45     OpBuilder builder(&context);
  46     OperationState state(UnknownLoc::get(&context),
  47                          spirv::ModuleOp::getOperationName());
  48     state.addAttribute("addressing_model",
  49                        builder.getI32IntegerAttr(static_cast<uint32_t>(
  50                            spirv::AddressingModel::Logical)));
  51     state.addAttribute("memory_model",
  52                        builder.getI32IntegerAttr(
  53                            static_cast<uint32_t>(spirv::MemoryModel::GLSL450)));
  54     state.addAttribute("vce_triple",
  55                        spirv::VerCapExtAttr::get(
  56                            spirv::Version::V_1_0, ArrayRef<spirv::Capability>(),
  57                            ArrayRef<spirv::Extension>(), &context));
  58     spirv::ModuleOp::build(builder, state);
  59     module = cast<spirv::ModuleOp>(Operation::create(state));
  60   }
  61
  62   /// Gets the `struct { float }` type.
  63   spirv::StructType getFloatStructType() {
  64     OpBuilder builder(module->getRegion());
  65     llvm::SmallVector<Type, 1> elementTypes{builder.getF32Type()};
  66     llvm::SmallVector<spirv::StructType::OffsetInfo, 1> offsetInfo{0};
  67     return spirv::StructType::get(elementTypes, offsetInfo);
  68   }
  69
  70   /// Inserts a global variable of the given `type` and `name`.
  71   spirv::GlobalVariableOp addGlobalVar(Type type, llvm::StringRef name) {
  72     OpBuilder builder(module->getRegion());
  73     auto ptrType = spirv::PointerType::get(type, spirv::StorageClass::Uniform);
  74     return builder.create<spirv::GlobalVariableOp>(
  75         UnknownLoc::get(&context), TypeAttr::get(ptrType),
  76         builder.getStringAttr(name), nullptr);
  77   }
  78
  79   /// Handles a SPIR-V instruction with the given `opcode` and `operand`.
  80   /// Returns true to interrupt.
  81   using HandleFn = llvm::function_ref<bool(spirv::Opcode opcode,
  82                                            ArrayRef<uint32_t> operands)>;
  83
  84   /// Returns true if we can find a matching instruction in the SPIR-V blob.
  85   bool scanInstruction(HandleFn handleFn) {
  86     auto binarySize = binary.size();
  87     auto *begin = binary.begin();
  88     auto currOffset = spirv::kHeaderWordCount;
  89
  90     while (currOffset < binarySize) {
  91       auto wordCount = binary[currOffset] >> 16;
  92       if (!wordCount || (currOffset + wordCount > binarySize))
  93         return false;
  94
  95       spirv::Opcode opcode =
  96           static_cast<spirv::Opcode>(binary[currOffset] & 0xffff);
  97       llvm::ArrayRef<uint32_t> operands(begin + currOffset + 1,
  98                                         begin + currOffset + wordCount);
  99       if (handleFn(opcode, operands))
 100         return true;
 101
 102       currOffset += wordCount;
 103     }
 104     return false;
 105   }
 106
 107 protected:
 108   MLIRContext context;
 109   OwningOpRef<spirv::ModuleOp> module;
 110   SmallVector<uint32_t, 0> binary;
 111 };
 112
 113 //===----------------------------------------------------------------------===//
 114 // Block decoration
 115 //===----------------------------------------------------------------------===//
 116
 117 TEST_F(SerializationTest, ContainsBlockDecoration) {
 118   auto structType = getFloatStructType();
 119   addGlobalVar(structType, "var0");
 120
 121   ASSERT_TRUE(succeeded(spirv::serialize(module.get(), binary)));
 122
 123   auto hasBlockDecoration = [](spirv::Opcode opcode,
 124                                ArrayRef<uint32_t> operands) {
 125     return opcode == spirv::Opcode::OpDecorate && operands.size() == 2 &&
 126            operands[1] == static_cast<uint32_t>(spirv::Decoration::Block);
 127   };
 128   EXPECT_TRUE(scanInstruction(hasBlockDecoration));
 129 }
 130
 131 TEST_F(SerializationTest, ContainsNoDuplicatedBlockDecoration) {
 132   auto structType = getFloatStructType();
 133   // Two global variables using the same type should not decorate the type with
 134   // duplicated `Block` decorations.
 135   addGlobalVar(structType, "var0");
 136   addGlobalVar(structType, "var1");
 137
 138   ASSERT_TRUE(succeeded(spirv::serialize(module.get(), binary)));
 139
 140   unsigned count = 0;
 141   auto countBlockDecoration = [&count](spirv::Opcode opcode,
 142                                        ArrayRef<uint32_t> operands) {
 143     if (opcode == spirv::Opcode::OpDecorate && operands.size() == 2 &&
 144         operands[1] == static_cast<uint32_t>(spirv::Decoration::Block))
 145       ++count;
 146     return false;
 147   };
 148   ASSERT_FALSE(scanInstruction(countBlockDecoration));
 149   EXPECT_EQ(count, 1u);
 150 }
 151
 152 TEST_F(SerializationTest, ContainsSymbolName) {
 153   auto structType = getFloatStructType();
 154   addGlobalVar(structType, "var0");
 155
 156   spirv::SerializationOptions options;
 157   options.emitSymbolName = true;
 158   ASSERT_TRUE(succeeded(spirv::serialize(module.get(), binary, options)));
 159
 160   auto hasVarName = [](spirv::Opcode opcode, ArrayRef<uint32_t> operands) {
 161     unsigned index = 1; // Skip the result <id>
 162     return opcode == spirv::Opcode::OpName &&
 163            spirv::decodeStringLiteral(operands, index) == "var0";
 164   };
 165   EXPECT_TRUE(scanInstruction(hasVarName));
 166 }
 167
 168 TEST_F(SerializationTest, DoesNotContainSymbolName) {
 169   auto structType = getFloatStructType();
 170   addGlobalVar(structType, "var0");
 171
 172   spirv::SerializationOptions options;
 173   options.emitSymbolName = false;
 174   ASSERT_TRUE(succeeded(spirv::serialize(module.get(), binary, options)));
 175
 176   auto hasVarName = [](spirv::Opcode opcode, ArrayRef<uint32_t> operands) {
 177     unsigned index = 1; // Skip the result <id>
 178     return opcode == spirv::Opcode::OpName &&
 179            spirv::decodeStringLiteral(operands, index) == "var0";
 180   };
 181   EXPECT_FALSE(scanInstruction(hasVarName));
 182 }