[mlir][EDSL] Add divis and diviu and vector.extractelement

[dcaballe]

Summary

It also removes a few duplicated intrinsics in the vector EDSL.

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

 using std_alloca = ValueBuilder<AllocaOp>;
 using std_call = OperationBuilder<CallOp>;
 using std_create_complex = ValueBuilder<CreateComplexOp>;
 using std_constant = ValueBuilder<ConstantOp>;
 using std_constant_float = ValueBuilder<ConstantFloatOp>;
 using std_constant_index = ValueBuilder<ConstantIndexOp>;
 using std_constant_int = ValueBuilder<ConstantIntOp>;
 using std_dealloc = OperationBuilder<DeallocOp>;
+using std_divis = ValueBuilder<SignedDivIOp>;
+using std_diviu = ValueBuilder<UnsignedDivIOp>;
 using std_dim = ValueBuilder<DimOp>;
 using std_extract_element = ValueBuilder<ExtractElementOp>;
 using std_im = ValueBuilder<ImOp>;
 using std_index_cast = ValueBuilder<IndexCastOp>;
 using std_muli = ValueBuilder<MulIOp>;
 using std_mulf = ValueBuilder<MulFOp>;
 using std_memref_cast = ValueBuilder<MemRefCastOp>;
 using std_re = ValueBuilder<ReOp>;

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

 namespace edsc {
 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_extractelement = ValueBuilder<vector::ExtractElementOp>;
 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>;
 using vector_extract_slices = ValueBuilder<vector::ExtractSlicesOp>;
 using vector_insert_slices = ValueBuilder<vector::InsertSlicesOp>;
 using vector_extract_strided_slice =
     ValueBuilder<vector::ExtractStridedSliceOp>;
 using vector_insert_strided_slice = ValueBuilder<vector::InsertStridedSliceOp>;
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_EDSC_INTRINSICS_H_

mlir/test/EDSC/builder-api-test.cpp

TEST_FUNC(operator_and) {
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: [[AND:%.*]] = and [[ARG0]], [[ARG1]]
   //       CHECK: [[TRUE:%.*]] = constant true
   //       CHECK: subi [[TRUE]], [[AND]] : i1
   f.print(llvm::outs());
   f.erase();
 }
 
+TEST_FUNC(divis_op_i32) {
+  using namespace edsc::op;
+  auto f = makeFunction("divis_op", {}, {});
+
+  OpBuilder builder(f.getBody());
+  ScopedContext scope(builder, f.getLoc());
+  auto i32Type = builder.getI32Type();
+  std_divis(std_constant_int(10, i32Type), std_constant_int(2, i32Type));
+
+  // clang-format off
+  // CHECK-LABEL: @divis_op
+  //   CHECK-DAG:     {{.*}} = constant 10
+  //   CHECK-DAG:     {{.*}} = constant 2
+  //  CHECK-NEXT:     {{.*}} = divi_signed
+  // clang-format on
+  f.print(llvm::outs());
+  f.erase();
+}
+
+TEST_FUNC(diviu_op_i32) {
+  using namespace edsc::op;
+  auto f = makeFunction("diviu_op", {}, {});
+
+  OpBuilder builder(f.getBody());
+  ScopedContext scope(builder, f.getLoc());
+  auto i32Type = builder.getI32Type();
+  std_diviu(std_constant_int(10, i32Type), std_constant_int(2, i32Type));
+
+  // clang-format off
+  // CHECK-LABEL: @diviu_op
+  //   CHECK-DAG:     {{.*}} = constant 10
+  //   CHECK-DAG:     {{.*}} = constant 2
+  //  CHECK-NEXT:     {{.*}} = divi_unsigned
+  // clang-format on
+  f.print(llvm::outs());
+  f.erase();
+}
+
 TEST_FUNC(select_op_i32) {
   using namespace edsc::op;
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("select_op", {}, {memrefType});
 
   OpBuilder builder(f.getBody());
TEST_FUNC(linalg_tensors_test) {
   linalg_generic_pointwise_tanh(SA({i, j}), SC({i, j}));
   Value o1 = linalg_generic_matmul(A, B, tensorType)->getResult(0);
   linalg_generic_matmul(A, B, o1, tensorType);
 
   f.print(llvm::outs());
   f.erase();
 }
 
+TEST_FUNC(vector_extractelement_op_i32) {
+  using namespace edsc::op;
+  auto f = makeFunction("vector_extractelement_op", {}, {});
+
+  OpBuilder builder(f.getBody());
+  ScopedContext scope(builder, f.getLoc());
+  auto i32Type = builder.getI32Type();
+  auto vectorType = VectorType::get(/*shape=*/{8}, i32Type);
+  vector_extractelement(
+      i32Type, std_constant(vectorType, builder.getI32VectorAttr({10})),
+      std_constant_int(0, i32Type));
+
+  // clang-format off
+  // CHECK-LABEL: @vector_extractelement_op
+  //   CHECK-DAG:     {{.*}} = constant dense<10>
+  //   CHECK-DAG:     {{.*}} = constant 0
+  //  CHECK-NEXT:     {{.*}} = vector.extractelement
+  // clang-format on
+  f.print(llvm::outs());
+  f.erase();
+}
+
 // CHECK-LABEL: func @memref_vector_matmul_test(
 //  CHECK-SAME:   %[[A:.*]]: memref<?x?xvector<4x16xf32>>,
 //  CHECK-SAME:   %[[B:.*]]: memref<?x?xvector<16x8xf32>>,
 //  CHECK-SAME:   %[[C:.*]]: memref<?x?xvector<4x8xf32>>)
 //       CHECK:   linalg.generic {{.*}} %[[A]], %[[B]], %[[C]]
 //       CHECK:     vector.contract{{.*}}[affine_map<(d0, d1, d2) -> (d0,
 //  d2)>,
 //  CHECK-SAME:                       affine_map<(d0, d1, d2) -> (d2, d1)>,