[mlir][linalg] Print broadcast, map, reduce, transpose ins/outs on one line.

[pifon2a]

Summary

just a cosmetic change. Also it does not affect a lot of users.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static void printCommonStructuredOpParts(OpAsmPrinter &p, ValueRange inputs,
   if (!outputs.empty())
     p << " outs(" << outputs << " : " << outputs.getTypes() << ")";
 }
 
 static void printCommonStructuredOpPartsWithNewLine(OpAsmPrinter &p,
                                                     ValueRange inputs,
                                                     ValueRange outputs) {
   if (!inputs.empty()) {
-    p.printNewline();
-    p << "ins(" << inputs << " : " << inputs.getTypes() << ")";
+    p << " ins(" << inputs << " : " << inputs.getTypes() << ")";
   }
   if (!outputs.empty()) {
-    p.printNewline();
-    p << "outs(" << outputs << " : " << outputs.getTypes() << ")";
+    p << " outs(" << outputs << " : " << outputs.getTypes() << ")";
   }
 }
 //===----------------------------------------------------------------------===//
 // Specific parsing and printing for named structured ops created by ods-gen.
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseNamedStructuredOpRegion(
     OpAsmParser &parser, Region &region, unsigned numRegionArgs,
ParseResult MapOp::parse(OpAsmParser &parser, OperationState &result) {
   Region *body = result.addRegion();
   if (parser.parseRegion(*body, regionArgs))
     return failure();
 
   return success();
 }
 
 void MapOp::print(OpAsmPrinter &p) {
-  p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
       p, SmallVector<Value>(getDpsInputOperands()),
       SmallVector<Value>(getDpsInitOperands()));
   p.printOptionalAttrDict((*this)->getAttrs());
 
+  p.increaseIndent();
   p.printNewline();
   p << "(";
   llvm::interleaveComma(getMapper().getArguments(), p,
                         [&](auto arg) { p.printRegionArgument(arg); });
   p << ") ";
 
   p.printRegion(getMapper(), /*printEntryBlockArgs=*/false);
   p.decreaseIndent();
ParseResult ReduceOp::parse(OpAsmParser &parser, OperationState &result) {
   if (parser.parseRegion(*body, regionArgs))
     return failure();
 
   return success();
 }
 
 static void printDenseI64ArrayAttr(OpAsmPrinter &p, StringRef attributeName,
                                    ArrayRef<int64_t> attributeValue) {
-  p << attributeName << " = [" << attributeValue << "] ";
+  p << ' ' << attributeName << " = [" << attributeValue << "] ";
 }
 
 void ReduceOp::print(OpAsmPrinter &p) {
-  p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
       p, SmallVector<Value>(getDpsInputOperands()),
       SmallVector<Value>(getDpsInitOperands()));
-  p.printNewline();
 
   printDenseI64ArrayAttr(p, getDimensionsAttrName(), getDimensions());
   p.printOptionalAttrDict((*this)->getAttrs(), {getDimensionsAttrName()});
 
+  p.increaseIndent();
   p.printNewline();
   p << "(";
   llvm::interleaveComma(getCombiner().getArguments(), p,
                         [&](auto arg) { p.printRegionArgument(arg); });
   p << ") ";
 
   p.printRegion(getCombiner(), /*printEntryBlockArgs=*/false);
   p.decreaseIndent();

 
 void TransposeOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   if (!getResults().empty())
     setNameFn(getResults().front(), "transposed");
 }
 
 void TransposeOp::print(OpAsmPrinter &p) {
-  p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
       p, SmallVector<Value>(getDpsInputOperands()),
       SmallVector<Value>(getDpsInitOperands()));
-  p.printNewline();
-
   printDenseI64ArrayAttr(p, getPermutationAttrName(), getPermutation());
   p.printOptionalAttrDict((*this)->getAttrs(), {getPermutationAttrName()});
-  p.decreaseIndent();
 }
 
 LogicalResult TransposeOp::verify() {
   ArrayRef<int64_t> permutationRef = getPermutation();
 
   if (!isPermutationVector(permutationRef))
     return emitOpError("permutation is not valid");
 

 
 void BroadcastOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   if (!getResults().empty())
     setNameFn(getResults().front(), "broadcasted");
 }
 
 void BroadcastOp::print(OpAsmPrinter &p) {
-  p.increaseIndent();
   printCommonStructuredOpPartsWithNewLine(
       p, SmallVector<Value>(getDpsInputOperands()),
       SmallVector<Value>(getDpsInitOperands()));
-  p.printNewline();
-
   printDenseI64ArrayAttr(p, getDimensionsAttrName(), getDimensions());
   p.printOptionalAttrDict((*this)->getAttrs(), {getDimensionsAttrName()});
-  p.decreaseIndent();
 }
 
 LogicalResult BroadcastOp::verify() {
   ArrayRef<int64_t> dimensionsRef = getDimensions();
 
   auto inputType = getInput().getType();
   auto initType = getInit().getType();
 

mlir/test/Dialect/Linalg/one-shot-bufferize.mlir

 
 // -----
 
 // CHECK-LABEL: func @map_binary
 // CHECK-SAME:  %[[LHS:[0-9a-zA-Z]*]]: memref<64xf32
 // CHECK-SAME:  %[[RHS:[0-9a-zA-Z]*]]: memref<64xf32
 func.func @map_binary(%lhs: tensor<64xf32>, %rhs: tensor<64xf32>,
                       %init: tensor<64xf32>) -> tensor<64xf32> {
-   // CHECK:      linalg.map
-   // CHECK-NEXT: ins(%[[LHS]], %[[RHS]] : memref<64xf32
+   // CHECK:      linalg.map ins(%[[LHS]], %[[RHS]] : memref<64xf32
    %add = linalg.map
           ins(%lhs, %rhs: tensor<64xf32>, tensor<64xf32>)
           outs(%init:tensor<64xf32>)
           (%lhs_elem: f32, %rhs_elem: f32) {
             %0 = arith.addf %lhs_elem, %rhs_elem: f32
             linalg.yield %0: f32
           }
   func.return %add : tensor<64xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @reduce
 // CHECK-SAME:  %[[INPUT:.*]]: memref<16x32x64xf32
 func.func @reduce(%input: tensor<16x32x64xf32>,
                   %init: tensor<16x64xf32>) -> tensor<16x64xf32> {
-  // CHECK:     linalg.reduce
-  // CHECK-NEXT: ins(%[[INPUT]] : memref<16x32x64xf32
+  // CHECK:     linalg.reduce ins(%[[INPUT]] : memref<16x32x64xf32
   %reduce = linalg.reduce
       ins(%input:tensor<16x32x64xf32>)
       outs(%init:tensor<16x64xf32>)
       dimensions = [1]
       (%in: f32, %out: f32) {
         %0 = arith.addf %in, %out: f32
         linalg.yield %0: f32
       }
   func.return %reduce : tensor<16x64xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @transpose
 // CHECK-SAME:  %[[ARG0:.*]]: memref<16x32x64xf32
 func.func @transpose(%input: tensor<16x32x64xf32>,
                      %init: tensor<32x64x16xf32>) -> tensor<32x64x16xf32> {
-  // CHECK:      linalg.transpose
-  // CHECK-NEXT: ins(%[[ARG0]] : memref<16x32x64xf32
+  // CHECK:      linalg.transpose ins(%[[ARG0]] : memref<16x32x64xf32
   %transpose = linalg.transpose
       ins(%input:tensor<16x32x64xf32>)
       outs(%init:tensor<32x64x16xf32>)
       permutation = [1, 2, 0]
   func.return %transpose : tensor<32x64x16xf32>
 }
 
 // -----

mlir/test/Dialect/Linalg/roundtrip.mlir

%add = linalg.map
       outs(%init:tensor<64xf32>)
       () {
         %0 = arith.constant 0.0: f32
         linalg.yield %0: f32
       }
   func.return %add : tensor<64xf32>
 }
 // CHECK-LABEL: func @map_no_inputs
-//       CHECK:   linalg.map
-//  CHECK-NEXT:   outs
+//       CHECK:   linalg.map outs
 //  CHECK-NEXT:   () {
 //  CHECK-NEXT:     arith.constant
 //  CHECK-NEXT:     linalg.yield
 //  CHECK-NEXT:   }
 
 // -----
 
 func.func @map_binary(%lhs: tensor<64xf32>, %rhs: tensor<64xf32>,
                       %init: tensor<64xf32>) -> tensor<64xf32> {
    %add = linalg.map
           ins(%lhs, %rhs: tensor<64xf32>, tensor<64xf32>)
           outs(%init:tensor<64xf32>)
           (%lhs_elem: f32, %rhs_elem: f32) {
             %0 = arith.addf %lhs_elem, %rhs_elem: f32
             linalg.yield %0: f32
           }
   func.return %add : tensor<64xf32>
 }
 // CHECK-LABEL: func @map_binary
-//       CHECK:   linalg.map
-//  CHECK-NEXT:   ins
-//  CHECK-NEXT:   outs
+//       CHECK:   linalg.map ins
+//  CHECK-SAME:   outs
 //  CHECK-NEXT:   (%{{.*}}: f32, %{{.*}}: f32) {
 //  CHECK-NEXT:     arith.addf
 //  CHECK-NEXT:     linalg.yield
 //  CHECK-NEXT:   }
 
 // -----
 
 func.func @map_binary_memref(%lhs: memref<64xf32>, %rhs: memref<64xf32>,
%reduce = linalg.reduce
       dimensions = [1]
       (%in: f32, %out: f32) {
         %0 = arith.addf %in, %out: f32
         linalg.yield %0: f32
       }
   func.return %reduce : tensor<16x64xf32>
 }
 // CHECK-LABEL: func @reduce
-//       CHECK:   linalg.reduce
-//  CHECK-NEXT:   ins
-//  CHECK-NEXT:   outs
-//  CHECK-NEXT:   dimensions = [1]
+//       CHECK:   linalg.reduce ins
+//  CHECK-SAME:   outs
+//  CHECK-SAME:   dimensions = [1]
 //  CHECK-NEXT:   (%{{.*}}: f32, %{{.*}}: f32) {
 //  CHECK-NEXT:     arith.addf
 //  CHECK-NEXT:     linalg.yield
 //  CHECK-NEXT:   }
 
 // -----
 
 func.func @reduce_memref(%input: memref<16x32x64xf32>,
func.func @transpose(%input: tensor<16x32x64xf32>,
                      %init: tensor<32x64x16xf32>) -> tensor<32x64x16xf32> {
   %transpose = linalg.transpose
       ins(%input:tensor<16x32x64xf32>)
       outs(%init:tensor<32x64x16xf32>)
       permutation = [1, 2, 0]
   func.return %transpose : tensor<32x64x16xf32>
 }
 // CHECK-LABEL: func @transpose
-//      CHECK:    linalg.transpose
-// CHECK-NEXT:    ins
-// CHECK-NEXT:    outs
-// CHECK-NEXT:    permutation
+//      CHECK:    linalg.transpose ins
+// CHECK-SAME:    outs
+// CHECK-SAME:    permutation
 
 // -----
 
 func.func @transpose_memref(%input: memref<16x32x64xf32>,
                             %init: memref<32x64x16xf32>) {
   linalg.transpose
       ins(%input:memref<16x32x64xf32>)
       outs(%init:memref<32x64x16xf32>)
       permutation = [1, 2, 0]
   func.return
 }
 // CHECK-LABEL: func @transpose_memref
 
 // -----
 
 func.func @broadcast_static_sizes(%input: tensor<8x32xf32>,
                             %init: tensor<8x16x32xf32>) -> tensor<8x16x32xf32> {
   %bcast = linalg.broadcast
       ins(%input:tensor<8x32xf32>)
       outs(%init:tensor<8x16x32xf32>)
       dimensions = [1]
   func.return %bcast : tensor<8x16x32xf32>
 }
 // CHECK-LABEL: func @broadcast_static_sizes
-//      CHECK:    linalg.broadcast
-// CHECK-NEXT:    ins
-// CHECK-NEXT:    outs
-// CHECK-NEXT:    dimensions
+//      CHECK:    linalg.broadcast ins
+// CHECK-SAME:    outs
+// CHECK-SAME:    dimensions
 
 // -----
 
 func.func @broadcast_with_dynamic_sizes(
               %input: tensor<8x?xf32>, %init: tensor<8x16x?xf32>)
               -> tensor<8x16x?xf32> {
   %bcast = linalg.broadcast
       ins(%input:tensor<8x?xf32>)
       outs(%init:tensor<8x16x?xf32>)
       dimensions = [1]
   func.return %bcast : tensor<8x16x?xf32>
 }
 // CHECK-LABEL: func @broadcast_with_dynamic_sizes
-//      CHECK:    linalg.broadcast
-// CHECK-NEXT:    ins
-// CHECK-NEXT:    outs
-// CHECK-NEXT:    dimensions
+//      CHECK:    linalg.broadcast ins
+// CHECK-SAME:    outs
+// CHECK-SAME:    dimensions
 
 // -----
 
 func.func @broadcast_memref(%input: memref<8x32xf32>,
                             %init: memref<8x16x32xf32>) {
   linalg.broadcast
       ins(%input:memref<8x32xf32>)
       outs(%init:memref<8x16x32xf32>)
       dimensions = [1]
   func.return
 }
 
 // CHECK-LABEL: func @broadcast_memref
-//      CHECK:    linalg.broadcast
-// CHECK-NEXT:    ins
-// CHECK-NEXT:    outs
-// CHECK-NEXT:    dimensions
+//      CHECK:    linalg.broadcast ins
+// CHECK-SAME:    outs
+// CHECK-SAME:    dimensions