[mlir] NFC - Add a builder to vector.transpose

[nicolasvasilache]

Summary

Also expose some more vector ops to EDSCs.

[aartbik]

mlir/include/mlir/Dialect/Vector/VectorOps.td

1382

nit: transp is current name (that may not be a very good one, but let's stay consistent)

mlir/include/mlir/EDSC/Builders.h

361

Nit: here and below

others use Emits and Returns, so let's use the "s" form of verb in this and comments below

[nicolasvasilache]

Address review.

[nicolasvasilache]

Update.

mlir/include/mlir/Dialect/Vector/EDSC/Intrinsics.h

 namespace intrinsics {
 
 using vector_broadcast = ValueBuilder<vector::BroadcastOp>;
 using vector_contract = ValueBuilder<vector::ContractionOp>;
 using vector_insert = ValueBuilder<vector::InsertOp>;
 using vector_fma = ValueBuilder<vector::FMAOp>;
 using vector_extract = ValueBuilder<vector::ExtractOp>;
 using vector_matmul = ValueBuilder<vector::MatmulOp>;
+using vector_outerproduct = ValueBuilder<vector::OuterProductOp>;
 using vector_print = OperationBuilder<vector::PrintOp>;
 using vector_transfer_read = ValueBuilder<vector::TransferReadOp>;
 using vector_transfer_write = OperationBuilder<vector::TransferWriteOp>;
+using vector_transpose = ValueBuilder<vector::TransposeOp>;
 using vector_type_cast = ValueBuilder<vector::TypeCastOp>;
 using vector_insert = ValueBuilder<vector::InsertOp>;
 using vector_fma = ValueBuilder<vector::FMAOp>;
 using vector_extract = ValueBuilder<vector::ExtractOp>;
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_EDSC_INTRINSICS_H_

mlir/include/mlir/Dialect/Vector/VectorOps.td

let description = [{
     ```mlir
     %1 = vector.transpose %0, [1, 0] : vector<2x3xf32> to vector<3x2xf32>
 
      [ [a, b, c],       [ [a, d],
        [d, e, f] ]  ->    [b, e],
                           [c, f] ]
     ```
   }];
+  let builders = [OpBuilder<
+    "OpBuilder &builder, OperationState &result, Value vector, "
+    "ArrayRef<int64_t> permutation">];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return result().getType().cast<VectorType>();
     }
     void getTransp(SmallVectorImpl<int64_t> &results);
+    static StringRef getTranspAttrName() { return "transp"; }
   }];
   let assemblyFormat = [{
     $vector `,` $transp attr-dict `:` type($vector) `to` type($result)
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 

mlir/include/mlir/EDSC/Builders.h

public:
   Store operator=(const TemplatedIndexedValue &rhs) {
     return Store(rhs, value, indices);
   }
   Store operator=(Value rhs) { return Store(rhs, value, indices); }
 
   /// Emits a `load` when converting to a Value.
   operator Value() const { return Load(value, indices); }
 
+  /// Return the base memref.
   Value getBase() const { return value; }
 
+  /// Return the underlying memref.
+  MemRefType getMemRefType() const {
+    return value.getType().cast<MemRefType>();
+  }
+
+  /// Return the underlying MemRef elemental type cast as `T`.
+  template <typename T>
+  T getElementalTypeAs() const {
+    return value.getType().cast<MemRefType>().getElementType().cast<T>();
+  }
+
   /// Arithmetic operator overloadings.
   Value operator+(Value e);
   Value operator-(Value e);
   Value operator*(Value e);
   Value operator/(Value e);
   Value operator%(Value e);
   Value operator^(Value e);
   Value operator+(TemplatedIndexedValue e) {

mlir/lib/Dialect/Vector/VectorOps.cpp

 }
 
 static LogicalResult verify(TupleOp op) { return success(); }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
+void vector::TransposeOp::build(OpBuilder &builder, OperationState &result,
+                                Value vector, ArrayRef<int64_t> transp) {
+  VectorType vt = vector.getType().cast<VectorType>();
+  SmallVector<int64_t, 4> transposedShape(vt.getRank());
+  for (unsigned i = 0; i < transp.size(); ++i)
+    transposedShape[i] = vt.getShape()[transp[i]];
+
+  result.addOperands(vector);
+  result.addTypes(VectorType::get(transposedShape, vt.getElementType()));
+  result.addAttribute(getTranspAttrName(), builder.getI64ArrayAttr(transp));
+}
+
 // Eliminates transpose operations, which produce values identical to their
 // input values. This happens when the dimensions of the input vector remain in
 // their original order after the transpose operation.
 OpFoldResult TransposeOp::fold(ArrayRef<Attribute> operands) {
   SmallVector<int64_t, 4> transp;
   getTransp(transp);
 
   // Check if the permutation of the dimensions contains sequential values: