[mlir][NFC] Update several SPIRV operations to use declarative parsers.

[rriddle]

Summary

Depends On D73503

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[antiagainst]

Nice, thanks!!

[rriddle]

Rebase

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[rriddle]

Rebase

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

 def SPV_IsArrayType : CPred<"$_self.isa<::mlir::spirv::ArrayType>()">;
 def SPV_IsRTArrayType : CPred<"$_self.isa<::mlir::spirv::RuntimeArrayType>()">;
 def SPV_IsStructType : CPred<"$_self.isa<::mlir::spirv::StructType>()">;
 
 // See https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_types
 // for the definition of the following types and type categories.
 
 def SPV_Void : TypeAlias<NoneType, "void type">;
-def SPV_Bool : IntOfWidths<[1]>;
+def SPV_Bool : I<1>;
 def SPV_Integer : IntOfWidths<[8, 16, 32, 64]>;
 def SPV_Float : FloatOfWidths<[16, 32, 64]>;
 def SPV_Float16or32 : FloatOfWidths<[16, 32]>;
 def SPV_Vector : VectorOfLengthAndType<[2, 3, 4],
                                        [SPV_Bool, SPV_Integer, SPV_Float]>;
 // Component type check is done in the type parser for the following SPIR-V
 // dialect-specific types so we use "Any" here.
 def SPV_AnyPtr : Type<SPV_IsPtrType, "any SPIR-V pointer type">;

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

let arguments = (ins
     Variadic<SPV_Type>:$arguments
   );
 
   let results = (outs
     SPV_Optional<SPV_Type>:$result
   );
 
   let autogenSerialization = 0;
+
+  let assemblyFormat = [{
+    $callee `(` $arguments `)` attr-dict `:`
+    functional-type($arguments, results)
+  }];
 }
 
 // -----
 
 def SPV_LoopOp : SPV_Op<"loop", [InFunctionScope]> {
   let summary = "Define a structured loop.";
 
   let description = [{
let description = [{
     ```
   }];
 
   let arguments = (ins
     SPV_Type:$value
   );
 
   let results = (outs);
+
+  let assemblyFormat = "$value attr-dict `:` type($value)";
 }
 
 def SPV_SelectionOp : SPV_Op<"selection", [InFunctionScope]> {
   let summary = "Define a structured selection.";
 
   let description = [{
     SPIR-V can explicitly declare structured control-flow constructs using merge
     instructions. These explicitly declare a header block before the control

mlir/include/mlir/Dialect/SPIRV/SPIRVGroupOps.td

let arguments = (ins
     SPV_Bool:$predicate
   );
 
   let results = (outs
     SPV_I32Vec4:$result
   );
 
   let verifier = [{ return success(); }];
+
+  let assemblyFormat = "$predicate attr-dict `:` type($result)";
 }
 
 // -----
 
 #endif // SPIRV_GROUP_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

def SPV_UndefOp : SPV_Op<"undef", []> {
   let results = (outs
     SPV_Type:$result
   );
 
   let verifier = [{ return success(); }];
 
   let hasOpcode = 0;
   let autogenSerialization = 0;
+
+  let assemblyFormat = "attr-dict `:` type($result)";
 }
 
 // -----
 
 def SPV_VariableOp : SPV_Op<"Variable", []> {
   let summary = [{
     Allocate an object in memory, resulting in a pointer to it, which can be
     used with OpLoad and OpStore.

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

def SPV_AddressOfOp : SPV_Op<"_address_of", [InFunctionScope, NoSideEffect]> {
   );
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let builders = [OpBuilder<[{Builder *builder, OperationState &state,
                               spirv::GlobalVariableOp var}]>];
+
+  let assemblyFormat = "$variable attr-dict `:` type($pointer)";
 }
 
 def SPV_ConstantOp : SPV_Op<"constant", [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:
def SPV_ReferenceOfOp : SPV_Op<"_reference_of", [NoSideEffect]> {
 
   let results = (outs
     SPV_Type:$reference
   );
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
+
+  let assemblyFormat = "$spec_const attr-dict `:` type($reference)";
 }
 
 def SPV_SpecConstantOp : SPV_Op<"specConstant", [InModuleScope, Symbol]> {
   let summary = "The op that declares a SPIR-V specialization constant";
 
   let description = [{
     This op declares a SPIR-V scalar specialization constant. SPIR-V has
     multiple constant instructions covering different scalar types:

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 // spv._address_of
 //===----------------------------------------------------------------------===//
 
 void spirv::AddressOfOp::build(Builder *builder, OperationState &state,
                                spirv::GlobalVariableOp var) {
   build(builder, state, var.type(), builder->getSymbolRefAttr(var));
 }
 
-static ParseResult parseAddressOfOp(OpAsmParser &parser,
-                                    OperationState &state) {
-  FlatSymbolRefAttr varRefAttr;
-  Type type;
-  if (parser.parseAttribute(varRefAttr, Type(), kVariableAttrName,
-                            state.attributes) ||
-      parser.parseColonType(type)) {
-    return failure();
-  }
-  auto ptrType = type.dyn_cast<spirv::PointerType>();
-  if (!ptrType) {
-    return parser.emitError(parser.getCurrentLocation(),
-                            "expected spv.ptr type");
-  }
-  state.addTypes(ptrType);
-  return success();
-}
-
-static void print(spirv::AddressOfOp addressOfOp, OpAsmPrinter &printer) {
-  SmallVector<StringRef, 4> elidedAttrs;
-  printer << spirv::AddressOfOp::getOperationName();
-
-  // Print symbol name.
-  printer << ' ';
-  printer.printSymbolName(addressOfOp.variable());
-
-  // Print the type.
-  printer << " : " << addressOfOp.pointer().getType();
-}
-
 static LogicalResult verify(spirv::AddressOfOp addressOfOp) {
   auto varOp = dyn_cast_or_null<spirv::GlobalVariableOp>(
       SymbolTable::lookupNearestSymbolFrom(addressOfOp.getParentOp(),
                                            addressOfOp.variable()));
   if (!varOp) {
     return addressOfOp.emitOpError("expected spv.globalVariable symbol");
   }
   if (addressOfOp.pointer().getType() != varOp.type()) {
interleaveComma(values, printer, [&](Attribute a) {
     printer << a.cast<IntegerAttr>().getInt();
   });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.FunctionCall
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseFunctionCallOp(OpAsmParser &parser,
-                                       OperationState &state) {
-  FlatSymbolRefAttr calleeAttr;
-  FunctionType type;
-  SmallVector<OpAsmParser::OperandType, 4> operands;
-  auto loc = parser.getNameLoc();
-  if (parser.parseAttribute(calleeAttr, kCallee, state.attributes) ||
-      parser.parseOperandList(operands, OpAsmParser::Delimiter::Paren) ||
-      parser.parseColonType(type)) {
-    return failure();
-  }
-
-  auto funcType = type.dyn_cast<FunctionType>();
-  if (!funcType) {
-    return parser.emitError(loc, "expected function type, but provided ")
-           << type;
-  }
-
-  if (funcType.getNumResults() > 1) {
-    return parser.emitError(loc, "expected callee function to have 0 or 1 "
-                                 "result, but provided ")
-           << funcType.getNumResults();
-  }
-
-  return failure(parser.addTypesToList(funcType.getResults(), state.types) ||
-                 parser.resolveOperands(operands, funcType.getInputs(), loc,
-                                        state.operands));
-}
-
-static void print(spirv::FunctionCallOp functionCallOp, OpAsmPrinter &printer) {
-  SmallVector<Type, 4> argTypes(functionCallOp.getOperandTypes());
-  Type functionType = FunctionType::get(
-      argTypes, functionCallOp.getResultTypes(), functionCallOp.getContext());
-
-  printer << spirv::FunctionCallOp::getOperationName() << ' '
-          << functionCallOp.getAttr(kCallee) << '('
-          << functionCallOp.arguments() << ") : " << functionType;
-}
-
 static LogicalResult verify(spirv::FunctionCallOp functionCallOp) {
   auto fnName = functionCallOp.callee();
 
   auto funcOp = dyn_cast_or_null<FuncOp>(SymbolTable::lookupNearestSymbolFrom(
       functionCallOp.getParentOp(), fnName));
   if (!funcOp) {
     return functionCallOp.emitOpError("callee function '")
            << fnName << "' not found in nearest symbol table";
static LogicalResult verify(spirv::ModuleOp moduleOp) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv._reference_of
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseReferenceOfOp(OpAsmParser &parser,
-                                      OperationState &state) {
-  FlatSymbolRefAttr constRefAttr;
-  Type type;
-  if (parser.parseAttribute(constRefAttr, Type(), kSpecConstAttrName,
-                            state.attributes) ||
-      parser.parseColonType(type)) {
-    return failure();
-  }
-  return parser.addTypeToList(type, state.types);
-}
-
-static void print(spirv::ReferenceOfOp referenceOfOp, OpAsmPrinter &printer) {
-  printer << spirv::ReferenceOfOp::getOperationName() << ' ';
-  printer.printSymbolName(referenceOfOp.spec_const());
-  printer << " : " << referenceOfOp.reference().getType();
-}
-
 static LogicalResult verify(spirv::ReferenceOfOp referenceOfOp) {
   auto specConstOp = dyn_cast_or_null<spirv::SpecConstantOp>(
       SymbolTable::lookupNearestSymbolFrom(referenceOfOp.getParentOp(),
                                            referenceOfOp.spec_const()));
   if (!specConstOp) {
     return referenceOfOp.emitOpError("expected spv.specConstant symbol");
   }
   if (referenceOfOp.reference().getType() !=
static LogicalResult verify(spirv::ReturnOp returnOp) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.ReturnValue
 //===----------------------------------------------------------------------===//
 
-static ParseResult parseReturnValueOp(OpAsmParser &parser,
-                                      OperationState &state) {
-  OpAsmParser::OperandType retValInfo;
-  Type retValType;
-  return failure(parser.parseOperand(retValInfo) ||
-                 parser.parseColonType(retValType) ||
-                 parser.resolveOperand(retValInfo, retValType, state.operands));
-}
-
-static void print(spirv::ReturnValueOp retValOp, OpAsmPrinter &printer) {
-  printer << spirv::ReturnValueOp::getOperationName() << ' ' << retValOp.value()
-          << " : " << retValOp.value().getType();
-}
-
 static LogicalResult verify(spirv::ReturnValueOp retValOp) {
   auto funcOp = retValOp.getParentOfType<FuncOp>();
   auto numFnResults = funcOp.getType().getNumResults();
   if (numFnResults != 1)
     return retValOp.emitOpError(
                "returns 1 value but enclosing function requires ")
            << numFnResults << " results";
 
static LogicalResult verify(spirv::StoreOp storeOp) {
   if (failed(verifyLoadStorePtrAndValTypes(storeOp, storeOp.ptr(),
                                            storeOp.value()))) {
     return failure();
   }
   return verifyMemoryAccessAttribute(storeOp);
 }
 
 //===----------------------------------------------------------------------===//
-// spv.SubgroupBallotKHROp
-//===----------------------------------------------------------------------===//
-
-static ParseResult parseSubgroupBallotKHROp(OpAsmParser &parser,
-                                            OperationState &state) {
-  OpAsmParser::OperandType operandInfo;
-  Type resultType;
-  IntegerType i1Type = parser.getBuilder().getI1Type();
-  if (parser.parseOperand(operandInfo) || parser.parseColonType(resultType) ||
-      parser.resolveOperand(operandInfo, i1Type, state.operands))
-    return failure();
-
-  return parser.addTypeToList(resultType, state.types);
-}
-
-static void print(spirv::SubgroupBallotKHROp ballotOp, OpAsmPrinter &printer) {
-  printer << spirv::SubgroupBallotKHROp::getOperationName() << ' '
-          << ballotOp.predicate() << " : " << ballotOp.getType();
-}
-
-//===----------------------------------------------------------------------===//
-// spv.Undef
-//===----------------------------------------------------------------------===//
-
-static ParseResult parseUndefOp(OpAsmParser &parser, OperationState &state) {
-  Type type;
-  if (parser.parseColonType(type)) {
-    return failure();
-  }
-  state.addTypes(type);
-  return success();
-}
-
-static void print(spirv::UndefOp undefOp, OpAsmPrinter &printer) {
-  printer << spirv::UndefOp::getOperationName() << " : " << undefOp.getType();
-}
-
-//===----------------------------------------------------------------------===//
 // spv.Unreachable
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(spirv::UnreachableOp unreachableOp) {
   auto *op = unreachableOp.getOperation();
   auto *block = op->getBlock();
   // Fast track: if this is in entry block, its invalid. Otherwise, if no
   // predecessors, it's valid.

mlir/test/Dialect/SPIRV/control-flow-ops.mlir

func @caller() {
   spv.Return
 }
 
 // -----
 
 spv.module "Logical" "GLSL450" {
   func @f_invalid_result_type(%arg0 : i32, %arg1 : i32) -> () {
     // expected-error @+1 {{expected callee function to have 0 or 1 result, but provided 2}}
-    %0 = spv.FunctionCall @f_invalid_result_type(%arg0, %arg1) : (i32, i32) -> (i32, i32)
+    %0:2 = spv.FunctionCall @f_invalid_result_type(%arg0, %arg1) : (i32, i32) -> (i32, i32)
     spv.Return
   }
 }
 
 // -----
 
 spv.module "Logical" "GLSL450" {
   func @f_result_type_mismatch(%arg0 : i32, %arg1 : i32) -> () {