diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td @@ -621,23 +621,20 @@ : LLVM_OneResultOp<"mlir.null", [NoSideEffect]>, LLVM_Builder<"$res = llvm::ConstantPointerNull::get(" " cast($_resultType));"> { - let parser = [{ return parseNullOp(parser, result); }]; - let printer = [{ printNullOp(p, *this); }]; + let assemblyFormat = "attr-dict `:` type($res)"; let verifier = [{ return ::verify(*this); }]; } def LLVM_UndefOp : LLVM_OneResultOp<"mlir.undef", [NoSideEffect]>, LLVM_Builder<"$res = llvm::UndefValue::get($_resultType);"> { - let parser = [{ return parseUndefOp(parser, result); }]; - let printer = [{ printUndefOp(p, *this); }]; + let assemblyFormat = "attr-dict `:` type($res)"; } def LLVM_ConstantOp : LLVM_OneResultOp<"mlir.constant", [NoSideEffect]>, Arguments<(ins AnyAttr:$value)>, LLVM_Builder<"$res = getLLVMConstant($_resultType, $value, $_location);"> { - let parser = [{ return parseConstantOp(parser, result); }]; - let printer = [{ printConstantOp(p, *this); }]; + let assemblyFormat = "`(` $value `)` attr-dict `:` type($res)"; } // Operations that correspond to LLVM intrinsics. With MLIR operation set being diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td b/mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td --- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td +++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td @@ -56,6 +56,7 @@ // Fully specified by traits. let verifier = ?; + let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)"; } def Linalg_ReshapeOp : Linalg_Op<"reshape", [NoSideEffect]>, @@ -117,6 +118,9 @@ static StringRef getReassociationAttrName() { return "reassociation"; } MemRefType getViewType() { return view().getType().cast(); } }]; + let assemblyFormat = [{ + $view $reassociation attr-dict `:` type($view) `into` type(results) + }]; } def Linalg_SliceOp : Linalg_Op<"slice", [NoSideEffect]>, diff --git a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td --- a/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td +++ b/mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td @@ -183,8 +183,6 @@ class LinalgStructuredBase_Op props> : Op { - let parser = [{ return parseLinalgStructuredOp(parser, result); }]; - let printer = [{ printLinalgStructuredOp(p, *this); }]; } class LinalgStructured_Op props> @@ -194,6 +192,7 @@ return generateLibraryCallName(getOperation()); } }]; + let assemblyFormat = "`(` operands `)` attr-dict `:` type(operands)"; } //////////////////////////////////////////////////////////////////////////////// diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp @@ -731,28 +731,6 @@ return success(); } -//===----------------------------------------------------------------------===// -// Printing/parsing for LLVM::UndefOp. -//===----------------------------------------------------------------------===// - -static void printUndefOp(OpAsmPrinter &p, UndefOp &op) { - p << op.getOperationName(); - p.printOptionalAttrDict(op.getAttrs()); - p << " : " << op.res().getType(); -} - -// ::= `llvm.mlir.undef` attribute-dict? : type -static ParseResult parseUndefOp(OpAsmParser &parser, OperationState &result) { - Type type; - - if (parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type)) - return failure(); - - result.addTypes(type); - return success(); -} - //===----------------------------------------------------------------------===// // Printer, parser and verifier for LLVM::AddressOfOp. //===----------------------------------------------------------------------===// @@ -801,32 +779,6 @@ return success(); } -//===----------------------------------------------------------------------===// -// Printing/parsing for LLVM::ConstantOp. -//===----------------------------------------------------------------------===// - -static void printConstantOp(OpAsmPrinter &p, ConstantOp &op) { - p << op.getOperationName() << '(' << op.value() << ')'; - p.printOptionalAttrDict(op.getAttrs(), {"value"}); - p << " : " << op.res().getType(); -} - -// ::= `llvm.mlir.constant` `(` attribute `)` attribute-list? : type -static ParseResult parseConstantOp(OpAsmParser &parser, - OperationState &result) { - Attribute valueAttr; - Type type; - - if (parser.parseLParen() || - parser.parseAttribute(valueAttr, "value", result.attributes) || - parser.parseRParen() || parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type)) - return failure(); - - result.addTypes(type); - return success(); -} - //===----------------------------------------------------------------------===// // Builder, printer and verifier for LLVM::GlobalOp. //===----------------------------------------------------------------------===// @@ -1319,23 +1271,9 @@ } //===----------------------------------------------------------------------===// -// Printing, parsing and verification for LLVM::NullOp. +// Verification for LLVM::NullOp. //===----------------------------------------------------------------------===// -static void printNullOp(OpAsmPrinter &p, LLVM::NullOp op) { - p << NullOp::getOperationName(); - p.printOptionalAttrDict(op.getAttrs()); - p << " : " << op.getType(); -} - -// = `llvm.mlir.null` : type -static ParseResult parseNullOp(OpAsmParser &parser, OperationState &result) { - Type type; - return failure(parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type) || - parser.addTypeToList(type, result.types)); -} - // Only LLVM pointer types are supported. static LogicalResult verify(LLVM::NullOp op) { auto llvmType = op.getType().dyn_cast(); diff --git a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp --- a/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp +++ b/mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp @@ -295,30 +295,6 @@ static LogicalResult verify(GenericOp op) { return verifyGenericOp(op); } static LogicalResult verify(IndexedGenericOp op) { return verifyGenericOp(op); } -//===----------------------------------------------------------------------===// -// RangeOp -//===----------------------------------------------------------------------===// - -static void print(OpAsmPrinter &p, RangeOp op) { - p << op.getOperationName() << " " << op.min() << ":" << op.max() << ":" - << op.step(); - p.printOptionalAttrDict(op.getAttrs()); - p << " : " << op.getResult().getType(); -} - -static ParseResult parseRangeOp(OpAsmParser &parser, OperationState &result) { - SmallVector rangeInfo(3); - RangeType type; - auto indexTy = parser.getBuilder().getIndexType(); - return failure(parser.parseOperand(rangeInfo[0]) || parser.parseColon() || - parser.parseOperand(rangeInfo[1]) || parser.parseColon() || - parser.parseOperand(rangeInfo[2]) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type) || - parser.resolveOperands(rangeInfo, indexTy, result.operands) || - parser.addTypeToList(type, result.types)); -} - //===----------------------------------------------------------------------===// // ReshapeOp //===----------------------------------------------------------------------===// @@ -499,28 +475,6 @@ b->getAffineMapArrayAttr(maps)); } -static void print(OpAsmPrinter &p, ReshapeOp op) { - p << op.getOperationName() << " " << op.view() << " " << op.reassociation(); - p.printOptionalAttrDict(op.getAttrs(), - {ReshapeOp::getReassociationAttrName()}); - p << " : " << op.getViewType() << " into " << op.getResult().getType(); -} - -static ParseResult parseReshapeOp(OpAsmParser &parser, OperationState &result) { - OpAsmParser::OperandType view; - ArrayAttr reassociation; - MemRefType type, resultType; - return failure(parser.parseOperand(view) || - parser.parseAttribute(reassociation, - ReshapeOp::getReassociationAttrName(), - result.attributes) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type) || - parser.parseKeywordType("into", resultType) || - parser.resolveOperand(view, type, result.operands) || - parser.addTypeToList(resultType, result.types)); -} - static LogicalResult verify(ReshapeOp op) { MemRefType expandedType = op.getViewType(); MemRefType collapsedType = op.getResult().getType().cast(); @@ -754,43 +708,6 @@ } /////// Operations corresponding to library calls defined with Tablegen //////// -// For such operations correspond to library calls (i.e. defined in -// LinalgStructuredOps.td), we define an overloaded `print` function and a -// parse`className` function. - -// A LinalgStructuredOp prints as: -// -// ```mlir -// concrete_op_name (ssa-inputs, ssa-outputs) : view-types -// ``` -// -// for example: -// -// ``` -// linalg.matmul(%0, %1, %2) : -// memref, -// memref, -// memref -// ``` -// -// Where %0, %1 and %2 are ssa-values of type MemRefType with strides. -static void printLinalgStructuredOp(OpAsmPrinter &p, Operation *op) { - assert(op->getAbstractOperation() && "unregistered operation"); - p << op->getName().getStringRef() << "(" << op->getOperands() << ")"; - p.printOptionalAttrDict(op->getAttrs()); - p << " : " << op->getOperandTypes(); -} - -static ParseResult parseLinalgStructuredOp(OpAsmParser &parser, - OperationState &result) { - SmallVector ops; - SmallVector types; - return failure( - parser.parseOperandList(ops, OpAsmParser::Delimiter::Paren) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonTypeList(types) || - parser.resolveOperands(ops, types, parser.getNameLoc(), result.operands)); -} static LogicalResult verify(FillOp op) { auto viewType = op.getOutputShapedType(0); diff --git a/mlir/test/Dialect/Linalg/roundtrip.mlir b/mlir/test/Dialect/Linalg/roundtrip.mlir --- a/mlir/test/Dialect/Linalg/roundtrip.mlir +++ b/mlir/test/Dialect/Linalg/roundtrip.mlir @@ -29,7 +29,7 @@ return } // CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) { -// CHECK-NEXT: linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range +// CHECK-NEXT: linalg.range %{{.*}} : %{{.*}} : %{{.*}} : !linalg.range func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) { %c0 = constant 0 : index