[MLIR][SPIRV] Use getAsmResultName(...) hook for ConstantOp.

[ergawy]

Summary

Implements better naming for results of spv.Constant ops by making it
inherit from OpAsmOpInterface and implementing the associated
getAsmResultName(...) hook.

[mehdi_amini]

mlir/test/Dialect/SPIRV/IR/asm-op-interface.mlir

2

Please remove this option

2

This one as well, you're not using it.

2

What diagnostic are you checking here?

[antiagainst]

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

72

Nit: sort alphabetically?

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

1682

Vector type in SPIR-V can only be 1-D. That should already be guaranteed by the verifier. So we can just get the first dim here.

mlir/test/Dialect/SPIRV/IR/asm-op-interface.mlir

10

Add a test for negative number?

[ergawy]

Handle review comments.

mlir/test/Dialect/SPIRV/IR/asm-op-interface.mlir

2

Sorry, all of them are copy paste errors.

[antiagainst]

Thanks!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_
 #define MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVOpTraits.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

 // from the SPIR-V binary format in order to utilize MLIR mechanisms.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
 #define MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
+include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
   let summary = "Get the address of a global variable.";
def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
 
   let builders = [OpBuilder<(ins "spirv::GlobalVariableOp":$var)>];
 
   let assemblyFormat = "$variable attr-dict `:` type($pointer)";
 }
 
 // -----
 
-def SPV_ConstantOp : SPV_Op<"Constant", [ConstantLike, NoSideEffect]> {
+def SPV_ConstantOp : SPV_Op<"Constant",
+    [ConstantLike, DeclareOpInterfaceMethods<OpAsmOpInterface>, NoSideEffect]> {
   let summary = "The op that declares a SPIR-V normal constant";
 
   let description = [{
     This op declares a SPIR-V normal constant. SPIR-V has multiple constant
     instructions covering different constant types:
 
     * `OpConstantTrue` and `OpConstantFalse` for boolean constants
     * `OpConstant` for scalar constants

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

if (elemType.isa<FloatType>()) {
           DenseFPElementsAttr::get(vectorType,
                                    FloatAttr::get(elemType, 1.0).getValue()));
     }
   }
 
   llvm_unreachable("unimplemented types for ConstantOp::getOne()");
 }
 
+void mlir::spirv::ConstantOp::getAsmResultNames(
+    llvm::function_ref<void(mlir::Value, llvm::StringRef)> setNameFn) {
+  Type type = getType();
+
+  SmallString<32> specialNameBuffer;
+  llvm::raw_svector_ostream specialName(specialNameBuffer);
+  specialName << "cst";
+
+  IntegerType intTy = type.dyn_cast<IntegerType>();
+
+  if (IntegerAttr intCst = value().dyn_cast<IntegerAttr>()) {
+    if (intTy && intTy.getWidth() == 1) {
+      return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));
+    }
+
+    if (intTy.isSignless()) {
+      specialName << intCst.getInt();
+    } else {
+      specialName << intCst.getSInt();
+    }
+  }
+
+  if (intTy || type.isa<FloatType>()) {
+    specialName << '_' << type;
+  }
+
+  if (auto vecType = type.dyn_cast<VectorType>()) {
+    specialName << "_vec_";
+    specialName << vecType.getDimSize(0);
+
+    Type elementType = vecType.getElementType();
+
+    if (elementType.isa<IntegerType>() || elementType.isa<FloatType>()) {
+      specialName << "x" << elementType;
+    }
+  }
+
+  setNameFn(getResult(), specialName.str());
+}
+
 //===----------------------------------------------------------------------===//
 // spv.EntryPoint
 //===----------------------------------------------------------------------===//
 
 void spirv::EntryPointOp::build(OpBuilder &builder, OperationState &state,
                                 spirv::ExecutionModel executionModel,
                                 spirv::FuncOp function,
                                 ArrayRef<Attribute> interfaceVars) {

mlir/test/Dialect/SPIRV/IR/asm-op-interface.mlir

+// RUN: mlir-opt %s | FileCheck %s
+
+func @const() -> () {
+  // CHECK: %true
+  %0 = spv.Constant true
+  // CHECK: %false
+  %1 = spv.Constant false
+
+  // CHECK: %cst42_i32
+  %2 = spv.Constant 42 : i32
+  // CHECK: %cst-42_i32
+  %-2 = spv.Constant -42 : i32
+  // CHECK: %cst43_i64
+  %3 = spv.Constant 43 : i64
+
+  // CHECK: %cst_f32
+  %4 = spv.Constant 0.5 : f32
+  // CHECK: %cst_f64
+  %5 = spv.Constant 0.5 : f64
+
+  // CHECK: %cst_vec_3xi32 
+  %6 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
+
+  // CHECK: %cst
+  %8 = spv.Constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>>
+
+  return
+}

mlir/test/Dialect/SPIRV/IR/memory-ops.mlir

func @variable(%arg0: f32) -> () {
   // CHECK: spv.Variable : !spv.ptr<f32, Function>
   %0 = spv.Variable : !spv.ptr<f32, Function>
   return
 }
 
 // -----
 
 func @variable_init_normal_constant() -> () {
+  // CHECK: %[[cst:.*]] = spv.Constant
   %0 = spv.Constant 4.0 : f32
-  // CHECK: spv.Variable init(%0) : !spv.ptr<f32, Function>
+  // CHECK: spv.Variable init(%[[cst]]) : !spv.ptr<f32, Function>
   %1 = spv.Variable init(%0) : !spv.ptr<f32, Function>
   return
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   spv.GlobalVariable @global : !spv.ptr<f32, Workgroup>