[mlir][EDSC] Retire OperationHandle

[nicolasvasilache]

Summary

OperationHandle mostly existed to mirror the behavior of ValueHandle.
This has become unnecessary and can be retired.

[nicolasvasilache]

Cleanups.

[ftynse]

Nice clean-up!

mlir/include/mlir/EDSC/Builders.h

175

Nit (and likely for a separate clean-up): ArrayRef<Value> -> ValueRange

mlir/lib/Dialect/LoopOps/EDSC/Builders.cpp

101

Nit: these aren't handles anymore AFAICS

[nicolasvasilache]

Rebase

mlir/include/mlir/Dialect/Affine/EDSC/Builders.h

 template <typename Load, typename Store>
 Value TemplatedIndexedValue<Load, Store>::operator^(Value e) {
   using op::operator^;
   return static_cast<Value>(*this) ^ e;
 }
 
 /// Assignment-arithmetic operator overloadings.
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator+=(Value e) {
   using op::operator+;
-  return Store(*this + e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this + e, getBase(), indices);
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator-=(Value e) {
   using op::operator-;
-  return Store(*this - e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this - e, getBase(), indices);
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator*=(Value e) {
   using op::operator*;
-  return Store(*this * e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this * e, getBase(), indices);
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator/=(Value e) {
   using op::operator/;
-  return Store(*this / e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this / e, getBase(), indices);
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator%=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator%=(Value e) {
   using op::operator%;
-  return Store(*this % e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this % e, getBase(), indices);
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator^=(Value e) {
+Store TemplatedIndexedValue<Load, Store>::operator^=(Value e) {
   using op::operator^;
-  return Store(*this ^ e, getBase(), {indices.begin(), indices.end()});
+  return Store(*this ^ e, getBase(), indices);
 }
 
 /// Logical operator overloadings.
 template <typename Load, typename Store>
 Value TemplatedIndexedValue<Load, Store>::operator&&(Value e) {
   using op::operator&&;
   return static_cast<Value>(*this) && e;
 }

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

 //===- Intrinsics.h - MLIR EDSC Intrinsics for AffineOps --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_AFFINE_EDSC_INTRINSICS_H_
 #define MLIR_DIALECT_AFFINE_EDSC_INTRINSICS_H_
 
 #include "mlir/Dialect/Affine/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 
 namespace mlir {
 namespace edsc {
 namespace intrinsics {
 
 using affine_apply = ValueBuilder<AffineApplyOp>;
 using affine_if = OperationBuilder<AffineIfOp>;
 using affine_load = ValueBuilder<AffineLoadOp>;

mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h

 #ifndef MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 #define MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 // TODO(ntv): Needed for SubViewOp::Range, clean this up.
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 
 namespace mlir {
 class AffineForOp;
 class BlockArgument;
 class SubViewOp;
 

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

 //===- Intrinsics.h - MLIR EDSC Intrinsics for Linalg -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_LOOPOPS_EDSC_INTRINSICS_H_
 #define MLIR_DIALECT_LOOPOPS_EDSC_INTRINSICS_H_
 
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 
 namespace mlir {
 namespace edsc {
 namespace intrinsics {
+
 using loop_yield = OperationBuilder<loop::YieldOp>;
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LOOPOPS_EDSC_INTRINSICS_H_

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

 //===- Intrinsics.h - MLIR EDSC Intrinsics for StandardOps ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_
 #define MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_
 
 #include "mlir/Dialect/StandardOps/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 
 namespace mlir {
 namespace edsc {
 namespace intrinsics {
 
 using std_addf = ValueBuilder<AddFOp>;
 using std_alloc = ValueBuilder<AllocOp>;
 using std_call = OperationBuilder<CallOp>;

 using std_view = ValueBuilder<ViewOp>;
 using std_zero_extendi = ValueBuilder<ZeroExtendIOp>;
 using std_sign_extendi = ValueBuilder<SignExtendIOp>;
 
 /// Branches into the mlir::Block* captured by BlockHandle `b` with `operands`.
 ///
 /// Prerequisites:
 ///   All Handles have already captured previously constructed IR objects.
-OperationHandle std_br(BlockHandle bh, ArrayRef<Value> operands);
+BranchOp std_br(BlockHandle bh, ValueRange operands);
 
 /// Creates a new mlir::Block* and branches to it from the current block.
 /// Argument types are specified by `operands`.
 /// Captures the new block in `bh` and the actual `operands` in `captures`. To
 /// insert the new mlir::Block*, a local ScopedContext is constructed and
 /// released to the current block. The branch operation is then added to the
 /// new block.
 ///
 /// Prerequisites:
 ///   `b` has not yet captured an mlir::Block*.
 ///   No `captures` have captured any mlir::Value.
 ///   All `operands` have already captured an mlir::Value
 ///   captures.size() == operands.size()
 ///   captures and operands are pairwise of the same type.
-OperationHandle std_br(BlockHandle *bh, ArrayRef<Type> types,
-                       MutableArrayRef<Value> captures,
-                       ArrayRef<Value> operands);
+BranchOp std_br(BlockHandle *bh, ArrayRef<Type> types,
+                MutableArrayRef<Value> captures, ValueRange operands);
 
 /// Branches into the mlir::Block* captured by BlockHandle `trueBranch` with
 /// `trueOperands` if `cond` evaluates to `true` (resp. `falseBranch` and
 /// `falseOperand` if `cond` evaluates to `false`).
 ///
 /// Prerequisites:
 ///   All Handles have captured previously constructed IR objects.
-OperationHandle std_cond_br(Value cond, BlockHandle trueBranch,
-                            ArrayRef<Value> trueOperands,
-                            BlockHandle falseBranch,
-                            ArrayRef<Value> falseOperands);
+CondBranchOp std_cond_br(Value cond, BlockHandle trueBranch,
+                         ValueRange trueOperands, BlockHandle falseBranch,
+                         ValueRange falseOperands);
 
 /// Eagerly creates new mlir::Block* with argument types specified by
 /// `trueOperands`/`falseOperands`.
 /// Captures the new blocks in `trueBranch`/`falseBranch` and the arguments in
 /// `trueCaptures/falseCaptures`.
 /// To insert the new mlir::Block*, a local ScopedContext is constructed and
 /// released. The branch operation is then added in the original location and
 /// targeting the eagerly constructed blocks.
 ///
 /// Prerequisites:
 ///   `trueBranch`/`falseBranch` has not yet captured an mlir::Block*.
 ///   No `trueCaptures`/`falseCaptures` have captured any mlir::Value.
 ///   All `trueOperands`/`trueOperands` have already captured an mlir::Value
 ///   `trueCaptures`.size() == `trueOperands`.size()
 ///   `falseCaptures`.size() == `falseOperands`.size()
 ///   `trueCaptures` and `trueOperands` are pairwise of the same type
 ///   `falseCaptures` and `falseOperands` are pairwise of the same type.
-OperationHandle std_cond_br(Value cond, BlockHandle *trueBranch,
-                            ArrayRef<Type> trueTypes,
-                            MutableArrayRef<Value> trueCaptures,
-                            ArrayRef<Value> trueOperands,
-                            BlockHandle *falseBranch, ArrayRef<Type> falseTypes,
-                            MutableArrayRef<Value> falseCaptures,
-                            ArrayRef<Value> falseOperands);
+CondBranchOp
+std_cond_br(Value cond, BlockHandle *trueBranch, ArrayRef<Type> trueTypes,
+            MutableArrayRef<Value> trueCaptures, ValueRange trueOperands,
+            MutableArrayRef<Value> falseCaptures, ValueRange falseOperands);
 
 /// Provide an index notation around sdt_load and std_store.
 using StdIndexedValue =
     TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

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

 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_VECTOR_EDSC_BUILDERS_H_
 #define MLIR_DIALECT_VECTOR_EDSC_BUILDERS_H_
 
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 
 namespace mlir {
 namespace edsc {
 namespace ops {
 
 /// Build a generic vector contraction, that is a `vector.contract` op with

mlir/include/mlir/EDSC/Builders.h

private:
   Location location;
   /// Parent context we return into.
   ScopedContext *enclosingScopedContext;
   /// Defensively keeps track of the current NestedBuilder to ensure proper
   /// scoping usage.
   NestedBuilder *nestedBuilder;
 };
 
-template <typename Op>
-struct ValueBuilder {
-  // Builder-based
-  template <typename... Args>
-  ValueBuilder(Args... args) {
-    Operation *op = ScopedContext::getBuilder()
-                        .create<Op>(ScopedContext::getLocation(), args...)
-                        .getOperation();
-    if (op->getNumResults() != 1)
-      llvm_unreachable("unsupported operation, use OperationBuilder instead");
-    value = op->getResult(0);
+template <typename Op> struct ValueBuilder {
+  template <typename... Args> ValueBuilder(Args... args) {
+    value = ScopedContext::getBuilder()
+                .getResult();
   }
-
   operator Value() { return value; }
   Value value;
 };
 
+template <typename Op> struct OperationBuilder {
+  template <typename... Args> OperationBuilder(Args... args) {
+    op = ScopedContext::getBuilder().create<Op>(ScopedContext::getLocation(),
+                                                args...);
+  }
+  operator Op() { return op; }
+  operator Operation *() { return op.getOperation(); }
+  Op op;
+};
+
 /// A NestedBuilder is a scoping abstraction to create an idiomatic syntax
 /// embedded in C++ that serves the purpose of building nested MLIR.
 /// Nesting and compositionality is obtained by using the strict ordering that
 /// exists between object construction and method invocation on said object (in
 /// our case, the call to `operator()`).
 /// This ordering allows implementing an abstraction that decouples definition
 /// from declaration (in a PL sense) on placeholders.
 class NestedBuilder {
public:
   /// scoped within a LoopBuilder.
   void operator()(function_ref<void(void)> fun = nullptr);
   void setOp(Operation *op) { this->op = op; }
   Operation *getOp() { return op; }
 
 private:
   LoopBuilder() = default;
 
-  friend LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbHandles,
-                                           ArrayRef<Value> ubHandles,
-                                           int64_t step);
+  friend LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
+                                           ArrayRef<Value> ubs, int64_t step);
   friend LoopBuilder makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
-                                             ArrayRef<Value> lbHandles,
-                                             ArrayRef<Value> ubHandles,
+                                             ArrayRef<Value> lbs,
+                                             ArrayRef<Value> ubs,
                                              ArrayRef<Value> steps);
-  friend LoopBuilder makeLoopBuilder(Value *iv, Value lbHandle, Value ubHandle,
-                                     Value stepHandle,
+  friend LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
                                      MutableArrayRef<Value> iterArgsHandles,
                                      ValueRange iterArgsInitValues);
   Operation *op;
 };
 
 // This class exists solely to handle the C++ vexing parse case when
 // trying to enter a Block that has already been constructed.
 class Append {};
public:
   /// scoped within a BlockBuilder.
   void operator()(function_ref<void(void)> fun = nullptr);
 
 private:
   BlockBuilder(BlockBuilder &) = delete;
   BlockBuilder &operator=(BlockBuilder &other) = delete;
 };
 
-/// Base class for Value, OperationHandle and BlockHandle.
-/// Not meant to be used outside of these classes.
-class CapturableHandle {
-protected:
-  CapturableHandle() = default;
-};
-
-/// An OperationHandle can be used in lieu of Value to capture the
-/// operation in cases when one does not care about, or cannot extract, a
-/// unique Value from the operation.
-/// This can be used for capturing zero result operations as well as
-/// multi-result operations that are not supported by Value.
-/// We do not distinguish further between zero and multi-result operations at
-/// this time.
-struct OperationHandle : public CapturableHandle {
-  OperationHandle() : op(nullptr) {}
-  OperationHandle(Operation *op) : op(op) {}
-
-  OperationHandle(const OperationHandle &) = default;
-  OperationHandle &operator=(const OperationHandle &) = default;
-
-  /// Generic mlir::Op create. This is the key to being extensible to the whole
-  /// of MLIR without duplicating the type system or the op definitions.
-  template <typename Op, typename... Args>
-  static OperationHandle create(Args... args);
-  template <typename Op, typename... Args>
-  static Op createOp(Args... args);
-
-  /// Generic create for a named operation.
-  static OperationHandle create(StringRef name, ArrayRef<Value> operands,
-                                ArrayRef<Type> resultTypes,
-                                ArrayRef<NamedAttribute> attributes = {});
-
-  operator Operation *() { return op; }
-  Operation *getOperation() const { return op; }
-
-private:
-  Operation *op;
-};
-
 /// A BlockHandle represents a (potentially "delayed") Block abstraction.
 /// This extra abstraction is necessary because an mlir::Block is not an
 /// mlir::Value.
 /// A BlockHandle should be captured by pointer but otherwise passed by Value
 /// everywhere.
-class BlockHandle : public CapturableHandle {
+class BlockHandle {
 public:
   /// A BlockHandle constructed without an mlir::Block* represents a "delayed"
   /// Block. A delayed Block represents the declaration (in the PL sense) of a
   /// placeholder for an mlir::Block* that will be constructed and captured at
   /// some later point in the program.
   BlockHandle() : block(nullptr) {}
 
   /// A BlockHandle constructed with an mlir::Block* represents an "eager"

 
 private:
   // Only one of Value or type may be set.
   Type type;
   Value value;
   SmallVector<AffineExpr, 4> exprs;
 };
 
-template <typename Op, typename... Args>
-OperationHandle OperationHandle::create(Args... args) {
-  return OperationHandle(ScopedContext::getBuilder()
-                             .create<Op>(ScopedContext::getLocation(), args...)
-                             .getOperation());
-}
-
-template <typename Op, typename... Args>
-Op OperationHandle::createOp(Args... args) {
-  return cast<Op>(
-      OperationHandle(ScopedContext::getBuilder()
-                          .create<Op>(ScopedContext::getLocation(), args...)
-                          .getOperation())
-          .getOperation());
-}
-
 /// A TemplatedIndexedValue brings an index notation over the template Load and
 /// Store parameters. Assigning to an IndexedValue emits an actual `Store`
 /// operation, while converting an IndexedValue to a Value emits an actual
 /// `Load` operation.
-template <typename Load, typename Store>
-class TemplatedIndexedValue {
+template <typename Load, typename Store> class TemplatedIndexedValue {
 public:
   explicit TemplatedIndexedValue(Value v) : value(v) {}
 
   TemplatedIndexedValue(const TemplatedIndexedValue &rhs) = default;
 
   TemplatedIndexedValue operator()() { return *this; }
   /// Returns a new `TemplatedIndexedValue`.
   TemplatedIndexedValue operator()(Value index) {
     TemplatedIndexedValue res(value);
     res.indices.push_back(index);
     return res;
   }
   template <typename... Args>
   TemplatedIndexedValue operator()(Value index, Args... indices) {
     return TemplatedIndexedValue(value, index).append(indices...);
   }
   TemplatedIndexedValue operator()(ArrayRef<Value> indices) {
     return TemplatedIndexedValue(value, indices);
   }
 
   /// Emits a `store`.
-  OperationHandle operator=(const TemplatedIndexedValue &rhs) {
+  Store operator=(const TemplatedIndexedValue &rhs) {
     return Store(rhs, value, indices);
   }
-  OperationHandle operator=(Value 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); }
 
   Value getBase() const { return value; }
 
   /// Arithmetic operator overloadings.
   Value operator+(Value e);
public:
   Value operator%(TemplatedIndexedValue e) {
     return *this % static_cast<Value>(e);
   }
   Value operator^(TemplatedIndexedValue e) {
     return *this ^ static_cast<Value>(e);
   }
 
   /// Assignment-arithmetic operator overloadings.
-  OperationHandle operator+=(Value e);
-  OperationHandle operator-=(Value e);
-  OperationHandle operator*=(Value e);
-  OperationHandle operator/=(Value e);
-  OperationHandle operator%=(Value e);
-  OperationHandle operator^=(Value e);
-  OperationHandle operator+=(TemplatedIndexedValue e) {
+  Store operator+=(Value e);
+  Store operator-=(Value e);
+  Store operator*=(Value e);
+  Store operator/=(Value e);
+  Store operator%=(Value e);
+  Store operator^=(Value e);
+  Store operator+=(TemplatedIndexedValue e) {
     return this->operator+=(static_cast<Value>(e));
   }
-  OperationHandle operator-=(TemplatedIndexedValue e) {
+  Store operator-=(TemplatedIndexedValue e) {
     return this->operator-=(static_cast<Value>(e));
   }
-  OperationHandle operator*=(TemplatedIndexedValue e) {
+  Store operator*=(TemplatedIndexedValue e) {
     return this->operator*=(static_cast<Value>(e));
   }
-  OperationHandle operator/=(TemplatedIndexedValue e) {
+  Store operator/=(TemplatedIndexedValue e) {
     return this->operator/=(static_cast<Value>(e));
   }
-  OperationHandle operator%=(TemplatedIndexedValue e) {
+  Store operator%=(TemplatedIndexedValue e) {
     return this->operator%=(static_cast<Value>(e));
   }
-  OperationHandle operator^=(TemplatedIndexedValue e) {
+  Store operator^=(TemplatedIndexedValue e) {
     return this->operator^=(static_cast<Value>(e));
   }
 
   /// Logical operator overloadings.
   Value operator&&(Value e);
   Value operator||(Value e);
   Value operator&&(TemplatedIndexedValue e) {
     return *this && static_cast<Value>(e);

mlir/include/mlir/EDSC/Intrinsics.h

-//===- Intrinsics.h - MLIR Operations for Declarative Builders ---*- C++-*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Provides intuitive composable intrinsics for building snippets of MLIR
-// declaratively.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_EDSC_INTRINSICS_H_
-#define MLIR_EDSC_INTRINSICS_H_
-
-#include "mlir/EDSC/Builders.h"
-#include "mlir/IR/StandardTypes.h"
-#include "mlir/Support/LLVM.h"
-
-namespace mlir {
-
-class MemRefType;
-class Type;
-
-namespace edsc {
-
-/// Provides a set of first class intrinsics.
-/// In the future, most of intrinsics related to Operation that don't contain
-/// other operations should be Tablegen'd.
-namespace intrinsics {
-
-template <typename Op>
-struct OperationBuilder : public OperationHandle {
-  template <typename... Args>
-  OperationBuilder(Args... args)
-      : OperationHandle(OperationHandle::create<Op>(args...)) {}
-  OperationBuilder(ArrayRef<Value> vs)
-      : OperationHandle(OperationHandle::create<Op>(vs)) {}
-  template <typename... Args>
-  OperationBuilder(ArrayRef<Value> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(vs, args...)) {}
-  template <typename T, typename... Args>
-  OperationBuilder(T t, ArrayRef<Value> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(t, vs, args...)) {}
-  template <typename T1, typename T2, typename... Args>
-  OperationBuilder(T1 t1, T2 t2, ArrayRef<Value> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(t1, t2, vs, args...)) {}
-  OperationBuilder() : OperationHandle(OperationHandle::create<Op>()) {}
-};
-
-} // namespace intrinsics
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_EDSC_INTRINSICS_H_

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/AVX512/AVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::vector;
 using namespace mlir::avx512;
 
 template <typename OpTy>
 static Type getSrcVectorElementType(OpTy op) {
   return op.src().getType().template cast<VectorType>().getElementType();
 }
 

mlir/lib/Dialect/Linalg/EDSC/Builders.cpp

 
 mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(Value *iv, Value range) {
   assert(range.getType() && "expected !linalg.range type");
   assert(range.getDefiningOp() && "need operations to extract range parts");
   auto rangeOp = cast<RangeOp>(range.getDefiningOp());
   auto lb = rangeOp.min();
   auto ub = rangeOp.max();
   auto step = rangeOp.step();
-  auto forOp = OperationHandle::createOp<ForOp>(lb, ub, step);
+  ForOp forOp = OperationBuilder<ForOp>(lb, ub, step);
   *iv = forOp.getInductionVar();
   auto *body = forOp.getBody();
   enter(body, /*prev=*/1);
 }
 
 mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(Value *iv,
                                                SubViewOp::Range range) {
-  auto forOp =
-      OperationHandle::createOp<ForOp>(range.offset, range.size, range.stride);
+  ForOp forOp = OperationBuilder<ForOp>(range.offset, range.size, range.stride);
   *iv = forOp.getInductionVar();
   auto *body = forOp.getBody();
   enter(body, /*prev=*/1);
 }
 
 Value mlir::edsc::LoopRangeBuilder::operator()(std::function<void(void)> fun) {
   if (fun)
     fun();
   exit();
   return Value();
 }
 
 mlir::edsc::LoopNestRangeBuilder::LoopNestRangeBuilder(
     MutableArrayRef<Value> ivs, ArrayRef<SubViewOp::Range> ranges) {
   loops.reserve(ranges.size());
-  for (unsigned i = 0, e = ranges.size(); i < e; ++i) {
+  for (unsigned i = 0, e = ranges.size(); i < e; ++i)
     loops.emplace_back(&ivs[i], ranges[i]);
-  }
   assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
 }
 
 mlir::edsc::LoopNestRangeBuilder::LoopNestRangeBuilder(
     MutableArrayRef<Value> ivs, ArrayRef<Value> ranges) {
   loops.reserve(ranges.size());
-  for (unsigned i = 0, e = ranges.size(); i < e; ++i) {
+  for (unsigned i = 0, e = ranges.size(); i < e; ++i)
     loops.emplace_back(&ivs[i], ranges[i]);
-  }
   assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
 }
 
 Value LoopNestRangeBuilder::LoopNestRangeBuilder::operator()(
     std::function<void(void)> fun) {
   if (fun)
     fun();
   for (auto &lit : reverse(loops)) {

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

public:
 
   static void doit(ConcreteOpTy linalgOp, ArrayRef<Value> loopRanges,
                    MutableArrayRef<Value> allIvs) {
     // Only generate loop.parallel for outer consecutive "parallel"
     // iterator_types.
     // TODO(ravishankarm): Generate loop.parallel for all "parallel" iterator
     // types, not just the outer most ones. Also handle "reduction" iterator
     // types.
-    auto nPar = linalgOp.getNumParallelLoops();
-    auto nRed = linalgOp.getNumReductionLoops();
-    auto nWin = linalgOp.getNumWindowLoops();
-    auto nLoops = nPar + nRed + nWin;
     auto nOuterPar = linalgOp.iterator_types()
                          .getValue()
                          .take_while([](Attribute attr) {
                            return attr.cast<StringAttr>().getValue() ==
                                   getParallelIteratorTypeName();
                          })
                          .size();
     // If there are no outer parallel loops, then number of loop ops is same as
     // the number of loops, and they are all loop.for ops.
-    auto nLoopOps = (nOuterPar ? nLoops - nOuterPar + 1 : nLoops);
-    SmallVector<OperationHandle, 4> allLoops(nLoopOps, OperationHandle());
-    SmallVector<OperationHandle *, 4> allPLoops;
-    allPLoops.reserve(allLoops.size());
-    for (OperationHandle &loop : allLoops)
-      allPLoops.push_back(&loop);
-    ArrayRef<OperationHandle *> allPLoopsRef(allPLoops);
-
     if (nOuterPar) {
       GenericLoopNestRangeBuilder<loop::ParallelOp>(
           allIvs.take_front(nOuterPar), loopRanges.take_front(nOuterPar))([&] {
         GenericLoopNestRangeBuilder<loop::ForOp>(
             allIvs.drop_front(nOuterPar),
             loopRanges.drop_front(nOuterPar))([&] {
           SmallVector<Value, 4> allIvValues(allIvs.begin(), allIvs.end());
           LinalgScopedEmitter<StdIndexedValue, ConcreteOpTy>::

mlir/lib/Dialect/LoopOps/EDSC/Builders.cpp

mlir::edsc::LoopNestBuilder::LoopNestBuilder::operator()(
 
   return loops[0].getOp()->getResults();
 }
 
 LoopBuilder mlir::edsc::makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
                                                 ArrayRef<Value> lbs,
                                                 ArrayRef<Value> ubs,
                                                 ArrayRef<Value> steps) {
-  LoopBuilder result;
-  auto opHandle = OperationHandle::create<loop::ParallelOp>(lbs, ubs, steps);
-
-  loop::ParallelOp parallelOp =
-      cast<loop::ParallelOp>(*opHandle.getOperation());
+  loop::ParallelOp parallelOp = OperationBuilder<loop::ParallelOp>(
+      SmallVector<Value, 4>(lbs.begin(), lbs.end()),
+      SmallVector<Value, 4>(ubs.begin(), ubs.end()),
+      SmallVector<Value, 4>(steps.begin(), steps.end()));
   for (size_t i = 0, e = ivs.size(); i < e; ++i)
     ivs[i] = parallelOp.getBody()->getArgument(i);
+  LoopBuilder result;
   result.enter(parallelOp.getBody(), /*prev=*/1);
   return result;
 }
 
 mlir::edsc::LoopBuilder
 mlir::edsc::makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
                             MutableArrayRef<Value> iterArgsHandles,
                             ValueRange iterArgsInitValues) {
   mlir::edsc::LoopBuilder result;
-  auto forOp =
-      OperationHandle::createOp<loop::ForOp>(lb, ub, step, iterArgsInitValues);
-  *iv = forOp.getInductionVar();
+  loop::ForOp forOp =
+      OperationBuilder<loop::ForOp>(lb, ub, step, iterArgsInitValues);
+  *iv = Value(forOp.getInductionVar());
   auto *body = loop::getForInductionVarOwner(*iv).getBody();
   for (size_t i = 0, e = iterArgsHandles.size(); i < e; ++i) {
     // Skipping the induction variable.
     iterArgsHandles[i] = body->getArgument(i + 1);
   }
   result.setOp(forOp);
   result.enter(body, /*prev=*/1);
   return result;
 }

mlir/lib/Dialect/StandardOps/EDSC/Intrinsics.cpp

 //===- Intrinsics.cpp - MLIR Operations for Declarative Builders ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
-OperationHandle mlir::edsc::intrinsics::std_br(BlockHandle bh,
-                                               ArrayRef<Value> operands) {
+BranchOp mlir::edsc::intrinsics::std_br(BlockHandle bh, ValueRange operands) {
   assert(bh && "Expected already captured BlockHandle");
-  for (auto &o : operands) {
-    (void)o;
-    assert(o && "Expected already captured Value");
-  }
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
-  return OperationHandle::create<BranchOp>(bh.getBlock(), ops);
+  return OperationBuilder<BranchOp>(bh.getBlock(), ops);
 }
 
-OperationHandle mlir::edsc::intrinsics::std_br(BlockHandle *bh,
-                                               ArrayRef<Type> types,
-                                               MutableArrayRef<Value> captures,
-                                               ArrayRef<Value> operands) {
+BranchOp mlir::edsc::intrinsics::std_br(BlockHandle *bh, ArrayRef<Type> types,
+                                        ValueRange operands) {
   assert(!*bh && "Unexpected already captured BlockHandle");
   BlockBuilder(bh, types, captures)(/* no body */);
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
-  return OperationHandle::create<BranchOp>(bh->getBlock(), ops);
+  return OperationBuilder<BranchOp>(bh->getBlock(), ops);
 }
 
-OperationHandle mlir::edsc::intrinsics::std_cond_br(
-    Value cond, BlockHandle trueBranch, ArrayRef<Value> trueOperands,
-    BlockHandle falseBranch, ArrayRef<Value> falseOperands) {
+CondBranchOp mlir::edsc::intrinsics::std_cond_br(Value cond,
+                                                 BlockHandle trueBranch,
+                                                 ValueRange trueOperands,
+                                                 BlockHandle falseBranch,
+                                                 ValueRange falseOperands) {
   SmallVector<Value, 4> trueOps(trueOperands.begin(), trueOperands.end());
   SmallVector<Value, 4> falseOps(falseOperands.begin(), falseOperands.end());
-  return OperationHandle::create<CondBranchOp>(
-      cond, trueBranch.getBlock(), trueOps, falseBranch.getBlock(), falseOps);
+  return OperationBuilder<CondBranchOp>(cond, trueBranch.getBlock(), trueOps,
+                                        falseBranch.getBlock(), falseOps);
 }
 
-OperationHandle mlir::edsc::intrinsics::std_cond_br(
+CondBranchOp mlir::edsc::intrinsics::std_cond_br(
     Value cond, BlockHandle *trueBranch, ArrayRef<Type> trueTypes,
-    MutableArrayRef<Value> trueCaptures, ArrayRef<Value> trueOperands,
+    MutableArrayRef<Value> trueCaptures, ValueRange trueOperands,
     BlockHandle *falseBranch, ArrayRef<Type> falseTypes,
-    MutableArrayRef<Value> falseCaptures, ArrayRef<Value> falseOperands) {
+    MutableArrayRef<Value> falseCaptures, ValueRange falseOperands) {
   assert(!*trueBranch && "Unexpected already captured BlockHandle");
   assert(!*falseBranch && "Unexpected already captured BlockHandle");
   BlockBuilder(trueBranch, trueTypes, trueCaptures)(/* no body */);
   BlockBuilder(falseBranch, falseTypes, falseCaptures)(/* no body */);
   SmallVector<Value, 4> trueOps(trueOperands.begin(), trueOperands.end());
   SmallVector<Value, 4> falseOps(falseOperands.begin(), falseOperands.end());
-  return OperationHandle::create<CondBranchOp>(
-      cond, trueBranch->getBlock(), trueOps, falseBranch->getBlock(), falseOps);
+  return OperationBuilder<CondBranchOp>(cond, trueBranch->getBlock(), trueOps,
+                                        falseBranch->getBlock(), falseOps);
 }

mlir/lib/Dialect/Vector/EDSC/Builders.cpp

 //===- Builders.cpp - MLIR Declarative Linalg Builders --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Vector/EDSC/Builders.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::edsc::ops;
 

mlir/lib/EDSC/Builders.cpp

assert(ScopedContext::getCurrentScopedContext() &&
          "Unexpected Null ScopedContext");
   return ScopedContext::getCurrentScopedContext()->location;
 }
 
 MLIRContext *mlir::edsc::ScopedContext::getContext() {
   return getBuilder().getContext();
 }
 
-OperationHandle OperationHandle::create(StringRef name,
-                                        ArrayRef<Value> operands,
-                                        ArrayRef<Type> resultTypes,
-                                        ArrayRef<NamedAttribute> attributes) {
-  OperationState state(ScopedContext::getLocation(), name);
-  SmallVector<Value, 4> ops(operands.begin(), operands.end());
-  state.addOperands(ops);
-  state.addTypes(resultTypes);
-  for (const auto &attr : attributes) {
-    state.addAttribute(attr.first, attr.second);
-  }
-  return OperationHandle(ScopedContext::getBuilder().createOperation(state));
-}
-
 BlockHandle mlir::edsc::BlockHandle::create(ArrayRef<Type> argTypes) {
   auto &currentB = ScopedContext::getBuilder();
   auto *ib = currentB.getInsertionBlock();
   auto ip = currentB.getInsertionPoint();
   BlockHandle res;
   res.block = ScopedContext::getBuilder().createBlock(ib->getParent());
   // createBlock sets the insertion point inside the block.
   // We do not want this behavior when using declarative builders with nesting.

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

 
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Builders.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/LoopOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Pass/Pass.h"