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 @@ -269,8 +269,9 @@ def LLVM_GEPOp : LLVM_OneResultOp<"getelementptr", [NoSideEffect]>, Arguments<(ins LLVM_Type:$base, Variadic:$indices)>, LLVM_Builder<"$res = builder.CreateGEP($base, $indices);"> { - let parser = [{ return parseGEPOp(parser, result); }]; - let printer = [{ printGEPOp(p, *this); }]; + let assemblyFormat = [{ + $base `[` $indices `]` attr-dict `:` functional-type(operands, results) + }]; } def LLVM_LoadOp : LLVM_OneResultOp<"load">, Arguments<(ins LLVM_Type:$addr)>, LLVM_Builder<"$res = builder.CreateLoad($addr);"> { @@ -541,8 +542,7 @@ GlobalOp getGlobal(); }]; - let printer = "printAddressOfOp(p, *this);"; - let parser = "return parseAddressOfOp(parser, result);"; + let assemblyFormat = "$global_name attr-dict `:` type($res)"; let verifier = "return ::verify(*this);"; } @@ -659,23 +659,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,7 +118,9 @@ static StringRef getReassociationAttrName() { return "reassociation"; } MemRefType getViewType() { return view().getType().cast(); } }]; - + let assemblyFormat = [{ + $view $reassociation attr-dict `:` type($view) `into` type(results) + }]; let hasFolder = 1; } 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 @@ -153,51 +153,6 @@ } //===----------------------------------------------------------------------===// -// Printing/parsing for LLVM::GEPOp. -//===----------------------------------------------------------------------===// - -static void printGEPOp(OpAsmPrinter &p, GEPOp &op) { - SmallVector types(op.getOperandTypes()); - auto funcTy = FunctionType::get(types, op.getType(), op.getContext()); - - p << op.getOperationName() << ' ' << op.base() << '[' - << op.getOperands().drop_front() << ']'; - p.printOptionalAttrDict(op.getAttrs()); - p << " : " << funcTy; -} - -// ::= `llvm.getelementptr` ssa-use `[` ssa-use-list `]` -// attribute-dict? `:` type -static ParseResult parseGEPOp(OpAsmParser &parser, OperationState &result) { - OpAsmParser::OperandType base; - SmallVector indices; - Type type; - llvm::SMLoc trailingTypeLoc; - if (parser.parseOperand(base) || - parser.parseOperandList(indices, OpAsmParser::Delimiter::Square) || - parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() || - parser.getCurrentLocation(&trailingTypeLoc) || parser.parseType(type)) - return failure(); - - // Deconstruct the trailing function type to extract the types of the base - // pointer and result (same type) and the types of the indices. - auto funcType = type.dyn_cast(); - if (!funcType || funcType.getNumResults() != 1 || - funcType.getNumInputs() == 0) - return parser.emitError(trailingTypeLoc, - "expected trailing function type with at least " - "one argument and one result"); - - if (parser.resolveOperand(base, funcType.getInput(0), result.operands) || - parser.resolveOperands(indices, funcType.getInputs().drop_front(), - parser.getNameLoc(), result.operands)) - return failure(); - - result.addTypes(funcType.getResults()); - return success(); -} - -//===----------------------------------------------------------------------===// // Printing/parsing for LLVM::LoadOp. //===----------------------------------------------------------------------===// @@ -957,29 +912,7 @@ } //===----------------------------------------------------------------------===// -// 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. +// Verifier for LLVM::AddressOfOp. //===----------------------------------------------------------------------===// GlobalOp AddressOfOp::getGlobal() { @@ -991,27 +924,6 @@ mlir::SymbolTable::lookupSymbolIn(module, global_name())); } -static void printAddressOfOp(OpAsmPrinter &p, AddressOfOp op) { - p << op.getOperationName() << " "; - p.printSymbolName(op.global_name()); - p.printOptionalAttrDict(op.getAttrs(), {"global_name"}); - p << " : " << op.getResult().getType(); -} - -static ParseResult parseAddressOfOp(OpAsmParser &parser, - OperationState &result) { - Attribute symRef; - Type type; - if (parser.parseAttribute(symRef, "global_name", result.attributes) || - parser.parseOptionalAttrDict(result.attributes) || - parser.parseColonType(type) || parser.addTypeToList(type, result.types)) - return failure(); - - if (!symRef.isa()) - return parser.emitError(parser.getNameLoc(), "expected symbol reference"); - return success(); -} - static LogicalResult verify(AddressOfOp op) { auto global = op.getGlobal(); if (!global) @@ -1027,32 +939,6 @@ } //===----------------------------------------------------------------------===// -// 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. //===----------------------------------------------------------------------===// @@ -1516,23 +1402,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 @@ -380,30 +380,6 @@ 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 //===----------------------------------------------------------------------===// @@ -583,28 +559,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(); @@ -838,43 +792,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/LLVMIR/global.mlir b/mlir/test/Dialect/LLVMIR/global.mlir --- a/mlir/test/Dialect/LLVMIR/global.mlir +++ b/mlir/test/Dialect/LLVMIR/global.mlir @@ -118,7 +118,7 @@ func @foo() { // The attribute parser will consume the first colon-type, so we put two of // them to trigger the attribute type mismatch error. - // expected-error @+1 {{expected symbol reference}} + // expected-error @+1 {{invalid kind of attribute specified}} llvm.mlir.addressof "foo" : i64 : !llvm<"void ()*"> } diff --git a/mlir/test/Dialect/LLVMIR/invalid.mlir b/mlir/test/Dialect/LLVMIR/invalid.mlir --- a/mlir/test/Dialect/LLVMIR/invalid.mlir +++ b/mlir/test/Dialect/LLVMIR/invalid.mlir @@ -63,28 +63,28 @@ // ----- func @gep_missing_input_result_type(%pos : !llvm.i64, %base : !llvm<"float*">) { - // expected-error@+1 {{expected trailing function type with at least one argument and one result}} + // expected-error@+1 {{2 operands present, but expected 0}} llvm.getelementptr %base[%pos] : () -> () } // ----- func @gep_missing_input_type(%pos : !llvm.i64, %base : !llvm<"float*">) { - // expected-error@+1 {{expected trailing function type with at least one argument and one result}} + // expected-error@+1 {{2 operands present, but expected 0}} llvm.getelementptr %base[%pos] : () -> (!llvm<"float*">) } // ----- func @gep_missing_result_type(%pos : !llvm.i64, %base : !llvm<"float*">) { - // expected-error@+1 {{expected trailing function type with at least one argument and one result}} + // expected-error@+1 {{op requires one result}} llvm.getelementptr %base[%pos] : (!llvm<"float *">, !llvm.i64) -> () } // ----- func @gep_non_function_type(%pos : !llvm.i64, %base : !llvm<"float*">) { - // expected-error@+1 {{expected trailing function type with at least one argument and one result}} + // expected-error@+1 {{invalid kind of type specified}} llvm.getelementptr %base[%pos] : !llvm<"float*"> } 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