[mlir][EDSC] Retire ValueHandle

[nicolasvasilache]

Summary

The EDSC discussion thread points out that ValueHandle has become an unnecessary level of abstraction since MLIR switch from Value * to Value everywhere.

This revision removes this level of indirection.

[mehdi_amini]

Thanks for the cleanup! LGTM in principle, I don't know if anyone wants to review this in details...

[ftynse]

Thanks, great clean up, I like the simplification very much and happy to see this moving!

Most my comments are nits or ideas for further simplifications. Some bigger cleanup ideas (for separate commits):

• all of ArrayRef<Value> can now be replaced with ValueRange;
• all of ArrayRef<Type> can now be replaced with TypeRange;
• there is a couple of functions that became trivial and I wonder if they are worth keeping.

I've also seen some changes from ArrayRef<ValueHandle *> to one of ArrayRef<Value *>, SmallVectorImpl<Value> &, MutableArrayRef<Value> and I can't understand the logic behind the individual choices. My suggestion would be to consistently use one specific type (e.g. MutableArrayRef<Value>) eveywhere for consistency.

In D78691#1998456, @mehdi_amini wrote:

Thanks for the cleanup! LGTM in principle, I don't know if anyone wants to review this in details...

I did.

mlir/docs/EDSC.md

18–21

Nit: mlir::OpBuilder::create

35–36

Nit: reformat (this is a doc, so not automatic)

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

28–29

Nit: these are not lbHandles and ubHandles anymore

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

35

Nit these are not handles anymore

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

97

MutableArrayRef instead of ArrayRef<Value *> ? Okay for a separate commit, but you seem to be doing this already in loop builders.

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

87–88

Nit: BinaryHandle isn't a thing anymore. createBinaryOp ? Do we even need now that it's mostly trivial? Okay for a further cleanup.

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

164

I suppose you can drop the Value(fillOp.value()) magic and just do O(ivs) = fillOp now.

Also, consider using a plain "if" rather than a ternary here for readability.

221

nit: MutableArrayRef

325–326

Nit (for a separate clean up, and based on taste): I'd rather make getInputAndOutputIndices return a struct with named fields than a pair of vectors, the types in such fragment are not obvious

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

57

Nit: there are not Handles anymore, and how about MutableArrayRef<Value>?

105

No need for Value(...)

109

Not need for Value(...)

mlir/lib/EDSC/Builders.cpp

158

It looks like you could take a MutableArrayRef here instead (the code below assumes vector has enough elements), and ditch the version with ArrayRef<Value *> below.

Also, this calls for an assert(types.size() == args.size())

[nicolasvasilache]

Thanks for the review!

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

97

re MutableArrayRef<T> vs ArrayRef<T*>, both have issues: MutableArrayRef does not work with initializer lists but can be constructed from 2 pointers (begin, end) which leads to fun behavior. OTOH ArrayRef + vectors is clunky (i.e. the retired makeVectorHandlePtrs). For now I added the minimum necessary, we can reevaluate in the future.

[nicolasvasilache]

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

97

OTOH it's true the multiple possibilities make it more confusing and the most important, explicitly spelled out, use case (i.e. 1 capture) works with MutableArrayRef.
I just went ahead and updated everything with MutableArrayRef.

[nicolasvasilache]

Address review.

[nicolasvasilache]

Rebase

[nicolasvasilache]

Landed as 367229e100eca714276253bf95a0dd3d084a9624

[bondhugula]

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

87–89

Do we need these SmallVector's? You can change the args for this to ValueRange's actually.

mlir/docs/Dialects/Linalg.md

llvm::Optional<SmallVector<AffineMap, 8>> batchmatmul::referenceIndexingMaps() {
   return SmallVector<AffineMap, 8>{
       AffineMap::get(4, 0, {d0, d1, d3}),
       AffineMap::get(4, 0, {d3, d2}),
       AffineMap::get(4, 0, {d0, d1, d2}) };
 }
 void batchmatmul::regionBuilder(ArrayRef<BlockArgument> args) {
   using namespace edsc;
   using namespace intrinsics;
-  ValueHandle _0(args[0]), _1(args[1]), _2(args[2]);
-  ValueHandle _4 = std_mulf(_0, _1);
-  ValueHandle _5 = std_addf(_2, _4);
+  Value _0(args[0]), _1(args[1]), _2(args[2]);
+  Value _4 = std_mulf(_0, _1);
+  Value _5 = std_addf(_2, _4);
   (linalg_yield(ValueRange{ _5 }));
 }
 ```
 
 ## Open Issues and Design Alternatives<a name="open_issues"></a>
 Multiple open issues and design alternatives are in flight and it is time to
 lay them out for the community to discuss and pick apart:
 1. Should `linalg.generic` support nesting?

mlir/docs/EDSC.md

 # Background: declarative builders API
 
 The main purpose of the declarative builders API is to provide an intuitive way
 of constructing MLIR programmatically. In the majority of cases, the IR we wish
 to construct exhibits structured control-flow. The Declarative builders in the
 `EDSC` library (Embedded Domain Specific Constructs) provide an API to make MLIR
 construction and manipulation very idiomatic, for the structured control-flow
 case, in C++.
 
 ## ScopedContext
 
 `mlir::edsc::ScopedContext` provides an implicit thread-local context,
 supporting a simple declarative API with globally accessible builders. These
 declarative builders are available within the lifetime of a `ScopedContext`.
 
-## ValueHandle and IndexHandle
-
-`mlir::edsc::ValueHandle` and `mlir::edsc::IndexHandle` provide typed
-abstractions around an `mlir::Value`. These abstractions are "delayed", in the
-sense that they allow separating declaration from definition. They may capture
-IR snippets, as they are built, for programmatic manipulation. Intuitive
-operators are provided to allow concise and idiomatic expressions.
-
-```c++
-ValueHandle zero = std_constant_index(0);
-IndexHandle i, j, k;
-```
-
 ## Intrinsics
 
-`mlir::edsc::ValueBuilder` is a generic wrapper for the `mlir::Builder::create`
-method that operates on `ValueHandle` objects and return a single ValueHandle.
-For instructions that return no values or that return multiple values, the
-`mlir::edsc::InstructionBuilder` can be used. Named intrinsics are provided as
+`mlir::ValueBuilder` is a generic wrapper for the `mlir::OpBuilder::create`
+method that operates on `Value` objects and return a single Value. For
+instructions that return no values or that return multiple values, the
+`mlir::edsc::OperationBuilder` can be used. Named intrinsics are provided as
 syntactic sugar to further reduce boilerplate.
 
 ```c++
 using load = ValueBuilder<LoadOp>;
-using store = InstructionBuilder<StoreOp>;
+using store = OperationBuilder<StoreOp>;
 ```
 
 ## LoopBuilder and AffineLoopNestBuilder
 
 `mlir::edsc::AffineLoopNestBuilder` provides an interface to allow writing
 concise and structured loop nests.
 
 ```c++
   ScopedContext scope(f.get());
-  ValueHandle i(indexType),
-              j(indexType),
-              lb(f->getArgument(0)),
-              ub(f->getArgument(1));
-  ValueHandle f7(std_constant_float(llvm::APFloat(7.0f), f32Type)),
-              f13(std_constant_float(llvm::APFloat(13.0f), f32Type)),
-              i7(constant_int(7, 32)),
-              i13(constant_int(13, 32));
+  Value i, j, lb(f->getArgument(0)), ub(f->getArgument(1));
+  Value f7(std_constant_float(llvm::APFloat(7.0f), f32Type)),
   AffineLoopNestBuilder(&i, lb, ub, 3)([&]{
       lb * index_type(3) + ub;
       lb + index_type(3);
       AffineLoopNestBuilder(&j, lb, ub, 2)([&]{
           ceilDiv(index_type(31) * floorDiv(i + j * index_type(3), index_type(32)),
                   index_type(32));
           ((f7 + f13) / f7) % f13 - f7 * f13;
           ((i7 + i13) / i7) % i13 - i7 * i13;

 types. Here is what a definition of a general pointwise add looks in
 Tablegen with declarative builders.
 
 ```c++
 def AddOp : Op<"x.add">,
     Arguments<(ins Tensor:$A, Tensor:$B)>,
     Results<(outs Tensor: $C)> {
   code referenceImplementation = [{
-    auto ivs = makeIndexHandles(view_A.rank());
-    auto pivs = makePIndexHandles(ivs);
+    SmallVector<Value, 4> ivs(view_A.rank());
     IndexedValue A(arg_A), B(arg_B), C(arg_C);
-    AffineLoopNestBuilder(pivs, view_A.getLbs(), view_A.getUbs(), view_A.getSteps())(
-      [&]{
+    AffineLoopNestBuilder(
+      ivs, view_A.getLbs(), view_A.getUbs(), view_A.getSteps())([&]{
         C(ivs) = A(ivs) + B(ivs)
       });
   }];
 }
 ```
 
 Depending on the function signature on which this emitter is called, the
 generated IR resembles the following, for a 4-D memref of `vector<4xi8>`:

 //       CHECK: {{.*}} = addf {{.*}}, {{.*}} : f32
 //       CHECK: store {{.*}}, %arg2[] : memref<f32>
 ```
 
 Similar APIs are provided to emit the lower-level `loop.for` op with
 `LoopNestBuilder`. See the `builder-api-test.cpp` test for more usage examples.
 
 Since the implementation of declarative builders is in C++, it is also available
-to program the IR with an embedded-DSL flavor directly integrated in MLIR. We
-make use of these properties in the tutorial.
-
-Spoiler: MLIR also provides Python bindings for these builders, and a
-full-fledged Python machine learning DSL with automatic differentiation
-targeting MLIR was built as an early research collaboration.
-
+to program the IR with an embedded-DSL flavor directly integrated in MLIR.

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

 #include "mlir/EDSC/Builders.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
 namespace edsc {
 
 /// Constructs a new AffineForOp and captures the associated induction
-/// variable. A ValueHandle pointer is passed as the first argument and is the
+/// variable. A Value pointer is passed as the first argument and is the
 /// *only* way to capture the loop induction variable.
-LoopBuilder makeAffineLoopBuilder(ValueHandle *iv,
-                                  ArrayRef<ValueHandle> lbHandles,
-                                  ArrayRef<ValueHandle> ubHandles,
-                                  int64_t step);
+LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
+                                  ArrayRef<Value> ubs, int64_t step);
 
 /// Explicit nested LoopBuilder. Offers a compressed multi-loop builder to avoid
 /// explicitly writing all the loops in a nest. This simple functionality is
 /// also useful to write rank-agnostic custom ops.
 ///
 /// Usage:
 ///
 /// ```c++

 ///      }),
 ///    });
 /// ```
 class AffineLoopNestBuilder {
 public:
   /// This entry point accommodates the fact that AffineForOp implicitly uses
   /// multiple `lbs` and `ubs` with one single `iv` and `step` to encode `max`
   /// and and `min` constraints respectively.
-  AffineLoopNestBuilder(ValueHandle *iv, ArrayRef<ValueHandle> lbs,
-                        ArrayRef<ValueHandle> ubs, int64_t step);
-  AffineLoopNestBuilder(ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-                        ArrayRef<ValueHandle> ubs, ArrayRef<int64_t> steps);
+  AffineLoopNestBuilder(Value *iv, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
+                        int64_t step);
+  AffineLoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
+                        ArrayRef<Value> ubs, ArrayRef<int64_t> steps);
 
   void operator()(function_ref<void(void)> fun = nullptr);
 
 private:
   SmallVector<LoopBuilder, 4> loops;
 };
 
 namespace op {
 
-ValueHandle operator+(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator-(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator*(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator/(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator%(ValueHandle lhs, ValueHandle rhs);
-ValueHandle floorDiv(ValueHandle lhs, ValueHandle rhs);
-ValueHandle ceilDiv(ValueHandle lhs, ValueHandle rhs);
-
-ValueHandle operator!(ValueHandle value);
-ValueHandle operator&&(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator||(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator^(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator==(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator!=(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator<(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator<=(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator>(ValueHandle lhs, ValueHandle rhs);
-ValueHandle operator>=(ValueHandle lhs, ValueHandle rhs);
+Value operator+(Value lhs, Value rhs);
+Value operator-(Value lhs, Value rhs);
+Value operator*(Value lhs, Value rhs);
+Value operator/(Value lhs, Value rhs);
+Value operator%(Value lhs, Value rhs);
+Value floorDiv(Value lhs, Value rhs);
+Value ceilDiv(Value lhs, Value rhs);
+
+/// Logical operator overloadings.
+Value negate(Value value);
+Value operator&&(Value lhs, Value rhs);
+Value operator||(Value lhs, Value rhs);
+Value operator^(Value lhs, Value rhs);
+
+/// Comparison operator overloadings.
+Value eq(Value lhs, Value rhs);
+Value ne(Value lhs, Value rhs);
+Value operator<(Value lhs, Value rhs);
+Value operator<=(Value lhs, Value rhs);
+Value operator>(Value lhs, Value rhs);
+Value operator>=(Value lhs, Value rhs);
 
 } // namespace op
 
 /// Arithmetic operator overloadings.
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator+(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator+(Value e) {
   using op::operator+;
-  return static_cast<ValueHandle>(*this) + e;
+  return static_cast<Value>(*this) + e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator-(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator-(Value e) {
   using op::operator-;
-  return static_cast<ValueHandle>(*this) - e;
+  return static_cast<Value>(*this) - e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator*(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator*(Value e) {
   using op::operator*;
-  return static_cast<ValueHandle>(*this) * e;
+  return static_cast<Value>(*this) * e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator/(Value e) {
   using op::operator/;
-  return static_cast<ValueHandle>(*this) / e;
+  return static_cast<Value>(*this) / e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator%(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator%(Value e) {
   using op::operator%;
-  return static_cast<ValueHandle>(*this) % e;
+  return static_cast<Value>(*this) % e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator^(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator^(Value e) {
   using op::operator^;
-  return static_cast<ValueHandle>(*this) ^ e;
+  return static_cast<Value>(*this) ^ e;
 }
 
 /// Assignment-arithmetic operator overloadings.
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(Value e) {
   using op::operator+;
   return Store(*this + e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator-=(Value e) {
   using op::operator-;
   return Store(*this - e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(Value e) {
   using op::operator*;
   return Store(*this * e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator/=(Value e) {
   using op::operator/;
   return Store(*this / e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator%=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator%=(Value e) {
   using op::operator%;
   return Store(*this % e, getBase(), {indices.begin(), indices.end()});
 }
 template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator^=(ValueHandle e) {
+OperationHandle TemplatedIndexedValue<Load, Store>::operator^=(Value e) {
   using op::operator^;
   return Store(*this ^ e, getBase(), {indices.begin(), indices.end()});
 }
 
 /// Logical operator overloadings.
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator&&(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator&&(Value e) {
   using op::operator&&;
-  return static_cast<ValueHandle>(*this) && e;
+  return static_cast<Value>(*this) && e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator||(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator||(Value e) {
   using op::operator||;
-  return static_cast<ValueHandle>(*this) || e;
+  return static_cast<Value>(*this) || e;
 }
 
 /// Comparison operator overloadings.
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator==(ValueHandle e) {
-  using op::operator==;
-  return static_cast<ValueHandle>(*this) == e;
+Value TemplatedIndexedValue<Load, Store>::eq(Value e) {
+  return eq(value, e);
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator!=(ValueHandle e) {
-  using op::operator!=;
-  return static_cast<ValueHandle>(*this) != e;
+Value TemplatedIndexedValue<Load, Store>::ne(Value e) {
+  return ne(value, e);
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator<(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator<(Value e) {
   using op::operator<;
-  return static_cast<ValueHandle>(*this) < e;
+  return static_cast<Value>(*this) < e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator<=(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator<=(Value e) {
   using op::operator<=;
-  return static_cast<ValueHandle>(*this) <= e;
+  return static_cast<Value>(*this) <= e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator>(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator>(Value e) {
   using op::operator>;
-  return static_cast<ValueHandle>(*this) > e;
+  return static_cast<Value>(*this) > e;
 }
 template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator>=(ValueHandle e) {
+Value TemplatedIndexedValue<Load, Store>::operator>=(Value e) {
   using op::operator>=;
-  return static_cast<ValueHandle>(*this) >= e;
+  return static_cast<Value>(*this) >= e;
 }
 
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_EDSC_BUILDERS_H_

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

 
 /// A LoopRangeBuilder is a generic NestedBuilder for loop.for operations.
 /// More specifically it is meant to be used as a temporary object for
 /// representing any nested MLIR construct that is "related to" an mlir::Value
 /// (for now an induction variable).
 class LoopRangeBuilder : public NestedBuilder {
 public:
   /// Constructs a new loop.for and captures the associated induction
-  /// variable. A ValueHandle pointer is passed as the first argument and is the
+  /// variable. A Value pointer is passed as the first argument and is the
   /// *only* way to capture the loop induction variable.
-  LoopRangeBuilder(ValueHandle *iv, ValueHandle range);
-  LoopRangeBuilder(ValueHandle *iv, Value range);
-  LoopRangeBuilder(ValueHandle *iv, SubViewOp::Range range);
+  LoopRangeBuilder(Value *iv, Value range);
+  LoopRangeBuilder(Value *iv, SubViewOp::Range range);
 
   LoopRangeBuilder(const LoopRangeBuilder &) = delete;
   LoopRangeBuilder(LoopRangeBuilder &&) = default;
 
   LoopRangeBuilder &operator=(const LoopRangeBuilder &) = delete;
   LoopRangeBuilder &operator=(LoopRangeBuilder &&) = default;
 
   /// The only purpose of this operator is to serve as a sequence point so that
   /// the evaluation of `fun` (which build IR snippets in a scoped fashion) is
   /// scoped within a LoopRangeBuilder.
-  ValueHandle operator()(std::function<void(void)> fun = nullptr);
+  Value operator()(std::function<void(void)> fun = nullptr);
 };
 
 /// Helper class to sugar building loop.for loop nests from ranges.
 /// This is similar to edsc::AffineLoopNestBuilder except it works on ranges
 /// directly. In the current implementation it produces loop.for operations.
 class LoopNestRangeBuilder {
 public:
-  LoopNestRangeBuilder(ArrayRef<edsc::ValueHandle *> ivs,
-                       ArrayRef<edsc::ValueHandle> ranges);
-  LoopNestRangeBuilder(ArrayRef<edsc::ValueHandle *> ivs,
-                       ArrayRef<Value> ranges);
-  LoopNestRangeBuilder(ArrayRef<edsc::ValueHandle *> ivs,
+  LoopNestRangeBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> ranges);
+  LoopNestRangeBuilder(MutableArrayRef<Value> ivs,
                        ArrayRef<SubViewOp::Range> ranges);
-  edsc::ValueHandle operator()(std::function<void(void)> fun = nullptr);
+  Value operator()(std::function<void(void)> fun = nullptr);
 
 private:
   SmallVector<LoopRangeBuilder, 4> loops;
 };
 
 /// Helper template class for building loop.for and affine.loop nests from
 /// ranges.
 template <typename LoopTy> class GenericLoopNestRangeBuilder {
 public:
-  GenericLoopNestRangeBuilder(ArrayRef<edsc::ValueHandle *> ivs,
+  GenericLoopNestRangeBuilder(MutableArrayRef<Value> ivs,
                               ArrayRef<Value> ranges);
   void operator()(std::function<void(void)> fun = nullptr) { (*builder)(fun); }
 
 private:
   using LoopOrAffineLoopBuilder =
       typename std::conditional_t<std::is_same<LoopTy, AffineForOp>::value,
                                   AffineLoopNestBuilder, LoopNestRangeBuilder>;
   using BuilderType =
Operation *makeGenericLinalgOp(
     ArrayRef<IteratorType> iteratorTypes, ArrayRef<StructuredIndexed> inputs,
     ArrayRef<StructuredIndexed> outputs,
     function_ref<void(ArrayRef<BlockArgument>)> regionBuilder =
         defaultRegionBuilder,
     ArrayRef<Value> otherValues = {}, ArrayRef<Attribute> otherAttributes = {});
 
 namespace ops {
 using edsc::StructuredIndexed;
-using edsc::ValueHandle;
 
 //===----------------------------------------------------------------------===//
 // EDSC builders for linalg generic operations.
 //===----------------------------------------------------------------------===//
 
 /// Build the body of a region to compute a scalar multiply, under the current
 /// ScopedContext, at the current insert point.
 void mulRegionBuilder(ArrayRef<BlockArgument> args);

 /// build a perfect loop nest of parallel loops with arbitrarily complex
 /// innermost loop code and whatever (explicit) broadcast semantics.
 ///
 /// This can be used with both out-of-place and in-place semantics.
 /// The client is responsible for ensuring the region operations are compatible
 /// with in-place semantics and parallelism.
 
 /// Unary pointwise operation (with broadcast) entry point.
-using UnaryPointwiseOpBuilder = function_ref<Value(ValueHandle)>;
+using UnaryPointwiseOpBuilder = function_ref<Value(Value)>;
 Operation *linalg_generic_pointwise(UnaryPointwiseOpBuilder unaryOp,
                                     StructuredIndexed I, StructuredIndexed O);
 
 /// Build a linalg.pointwise with all `parallel` iterators and a region that
 /// computes `O = tanh(I)`. The client is responsible for specifying the proper
 /// indexings when creating the StructuredIndexed.
 Operation *linalg_generic_pointwise_tanh(StructuredIndexed I,
                                          StructuredIndexed O);
 
 /// Binary pointwise operation (with broadcast) entry point.
-using BinaryPointwiseOpBuilder = function_ref<Value(ValueHandle, ValueHandle)>;
+using BinaryPointwiseOpBuilder = function_ref<Value(Value, Value)>;
 Operation *linalg_generic_pointwise(BinaryPointwiseOpBuilder binaryOp,
                                     StructuredIndexed I1, StructuredIndexed I2,
                                     StructuredIndexed O);
 
 /// Build a linalg.pointwise with all `parallel` iterators and a region that
 /// computes `O = I1 + I2`. The client is responsible for specifying the proper
 /// indexings when creating the StructuredIndexed.
 Operation *linalg_generic_pointwise_add(StructuredIndexed I1,

 /// Build a linalg.generic, under the current ScopedContext, at the current
 /// insert point, that computes:
 /// ```
 ///    (m, n, k) = (par, par, seq)
 ///    |
 ///    |  C(m, n) += A(m, k) * B(k, n)
 /// ```
 Operation *
-linalg_generic_matmul(ValueHandle vA, ValueHandle vB, ValueHandle vC,
+linalg_generic_matmul(Value vA, Value vB, Value vC,
                       MatmulRegionBuilder regionBuilder = macRegionBuilder);
 
 /// Build a linalg.generic, under the current ScopedContext, at the current
 /// insert point, that computes:
 /// ```
 ///    (m, n, k) = (par, par, seq)
 ///    |
 ///    |  C(m, n) = sum_k(A(m, k) * B(k, n))
 /// ```
 /// and returns the tensor `C`.
 Operation *
-linalg_generic_matmul(ValueHandle vA, ValueHandle vB, RankedTensorType tC,
+linalg_generic_matmul(Value vA, Value vB, RankedTensorType tC,
                       MatmulRegionBuilder regionBuilder = mulRegionBuilder);
 
 /// Build a linalg.generic, under the current ScopedContext, at the current
 /// insert point, that computes:
 /// ```
 ///    (m, n, k) = (par, par, seq)
 ///    |
 ///    |  D(m, n) = C(m, n) + sum_k(A(m, k) * B(k, n))
 /// ```
 /// and returns the tensor `D`.
 Operation *
-linalg_generic_matmul(ValueHandle vA, ValueHandle vB, ValueHandle vC,
-                      RankedTensorType tD,
+linalg_generic_matmul(Value vA, Value vB, Value vC, RankedTensorType tD,
                       MatmulRegionBuilder regionBuilder = macRegionBuilder);
 
 template <typename Container>
 Operation *
 linalg_generic_matmul(Container values,
                       MatmulRegionBuilder regionBuilder = macRegionBuilder) {
   assert(values.size() == 3 && "Expected exactly 3 values");
   return linalg_generic_matmul(values[0], values[1], values[2], regionBuilder);

 ///    |   W([kh, kw, ...], c, f)
 /// ```
 /// If `dilations` or `strides` are left empty, the default value of `1` is used
 /// along each relevant dimension.
 ///
 /// For now `...` must be empty (i.e. only 2-D convolutions are supported).
 ///
 // TODO(ntv) Extend convolution rank with some template magic.
-Operation *linalg_generic_conv_nhwc(ValueHandle vI, ValueHandle vW,
-                                    ValueHandle vO, ArrayRef<int> strides = {},
+Operation *linalg_generic_conv_nhwc(Value vI, Value vW, Value vO,
+                                    ArrayRef<int> strides = {},
                                     ArrayRef<int> dilations = {});
 
 template <typename Container>
 Operation *linalg_generic_conv_nhwc(Container values,
                                     ArrayRef<int> strides = {},
                                     ArrayRef<int> dilations = {}) {
   assert(values.size() == 3 && "Expected exactly 3 values");
   return linalg_generic_conv_nhwc(values[0], values[1], values[2], strides,

 ///    |   W([kh, kw, ...], c, depth_multiplier)
 /// ```
 /// If `dilations` or `strides` are left empty, the default value of `1` is used
 /// along each relevant dimension.
 ///
 /// For now `...` must be empty (i.e. only 2-D convolutions are supported).
 ///
 // TODO(ntv) Extend convolution rank with some template magic.
-Operation *linalg_generic_dilated_conv_nhwc(ValueHandle vI, ValueHandle vW,
-                                            ValueHandle vO,
+Operation *linalg_generic_dilated_conv_nhwc(Value vI, Value vW, Value vO,
                                             int depth_multiplier = 1,
                                             ArrayRef<int> strides = {},
                                             ArrayRef<int> dilations = {});
 
 template <typename Container>
 Operation *linalg_generic_dilated_conv_nhwc(Container values,
                                             int depth_multiplier,
                                             ArrayRef<int> strides = {},

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

 
 #include "mlir/Dialect/Linalg/EDSC/Builders.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 
 #include "mlir/Transforms/FoldUtils.h"
 
 namespace mlir {
 namespace edsc {
+namespace intrinsics {
 
-template <typename Op, typename... Args>
-ValueHandle ValueHandle::create(OperationFolder *folder, Args... args) {
-  return folder ? ValueHandle(folder->create<Op>(ScopedContext::getBuilder(),
-                                                 ScopedContext::getLocation(),
-                                                 args...))
-                : ValueHandle(ScopedContext::getBuilder().create<Op>(
-                      ScopedContext::getLocation(), args...));
+template <typename Op>
+struct FoldedValueBuilder {
+  // Builder-based
+  template <typename... Args>
+  FoldedValueBuilder(OperationFolder *folder, Args... args) {
+    value = folder ? folder->create<Op>(ScopedContext::getBuilder(),
+                                        ScopedContext::getLocation(), args...)
+                   : ScopedContext::getBuilder().create<Op>(
+                         ScopedContext::getLocation(), args...);
   }
 
+  operator Value() { return value; }
+  Value value;
+};
+
+using folded_std_constant_index = FoldedValueBuilder<ConstantIndexOp>;
+using folded_std_constant_float = FoldedValueBuilder<ConstantFloatOp>;
+using folded_std_constant_int = FoldedValueBuilder<ConstantIntOp>;
+using folded_std_constant = FoldedValueBuilder<ConstantOp>;
+using folded_std_dim = FoldedValueBuilder<DimOp>;
+using folded_std_muli = FoldedValueBuilder<MulIOp>;
+using folded_std_addi = FoldedValueBuilder<AddIOp>;
+using folded_std_addf = FoldedValueBuilder<AddFOp>;
+using folded_std_alloc = FoldedValueBuilder<AllocOp>;
+using folded_std_constant = FoldedValueBuilder<ConstantOp>;
+using folded_std_constant_float = FoldedValueBuilder<ConstantFloatOp>;
+using folded_std_constant_index = FoldedValueBuilder<ConstantIndexOp>;
+using folded_std_constant_int = FoldedValueBuilder<ConstantIntOp>;
+using folded_std_dim = FoldedValueBuilder<DimOp>;
+using folded_std_extract_element = FoldedValueBuilder<ExtractElementOp>;
+using folded_std_index_cast = FoldedValueBuilder<IndexCastOp>;
+using folded_std_muli = FoldedValueBuilder<MulIOp>;
+using folded_std_mulf = FoldedValueBuilder<MulFOp>;
+using folded_std_memref_cast = FoldedValueBuilder<MemRefCastOp>;
+using folded_std_select = FoldedValueBuilder<SelectOp>;
+using folded_std_load = FoldedValueBuilder<LoadOp>;
+using folded_std_subi = FoldedValueBuilder<SubIOp>;
+using folded_std_sub_view = FoldedValueBuilder<SubViewOp>;
+using folded_std_tanh = FoldedValueBuilder<TanhOp>;
+using folded_std_tensor_load = FoldedValueBuilder<TensorLoadOp>;
+using folded_std_view = FoldedValueBuilder<ViewOp>;
+using folded_std_zero_extendi = FoldedValueBuilder<ZeroExtendIOp>;
+using folded_std_sign_extendi = FoldedValueBuilder<SignExtendIOp>;
+} // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_EDSC_FOLDEDINTRINSICS_H_

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

 #include "mlir/EDSC/Builders.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
 namespace edsc {
 
 /// Constructs a new loop::ParallelOp and captures the associated induction
-/// variables. An array of ValueHandle pointers is passed as the first
+/// variables. An array of Value pointers is passed as the first
 /// argument and is the *only* way to capture loop induction variables.
-LoopBuilder makeParallelLoopBuilder(ArrayRef<ValueHandle *> ivs,
-                                    ArrayRef<ValueHandle> lbHandles,
-                                    ArrayRef<ValueHandle> ubHandles,
-                                    ArrayRef<ValueHandle> steps);
+LoopBuilder makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
+                                    ArrayRef<Value> lbs, ArrayRef<Value> ubs,
+                                    ArrayRef<Value> steps);
 /// Constructs a new loop::ForOp and captures the associated induction
-/// variable. A ValueHandle pointer is passed as the first argument and is the
+/// variable. A Value pointer is passed as the first argument and is the
 /// *only* way to capture the loop induction variable.
-LoopBuilder makeLoopBuilder(ValueHandle *iv, ValueHandle lbHandle,
-                            ValueHandle ubHandle, ValueHandle stepHandle,
-                            ArrayRef<ValueHandle *> iter_args_handles = {},
-                            ValueRange iter_args_init_values = {});
+LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
+                            MutableArrayRef<Value> iterArgsHandles,
+                            ValueRange iterArgsInitValues);
+LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step,
+                            MutableArrayRef<Value> iterArgsHandles,
+                            ValueRange iterArgsInitValues);
+inline LoopBuilder makeLoopBuilder(Value *iv, Value lb, Value ub, Value step) {
+  return makeLoopBuilder(iv, lb, ub, step, MutableArrayRef<Value>{}, {});
+}
 
 /// Helper class to sugar building loop.parallel loop nests from lower/upper
 /// bounds and step sizes.
 class ParallelLoopNestBuilder {
 public:
-  ParallelLoopNestBuilder(ArrayRef<ValueHandle *> ivs,
-                          ArrayRef<ValueHandle> lbs, ArrayRef<ValueHandle> ubs,
-                          ArrayRef<ValueHandle> steps);
+  ParallelLoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
+                          ArrayRef<Value> ubs, ArrayRef<Value> steps);
 
   void operator()(function_ref<void(void)> fun = nullptr);
 
 private:
   SmallVector<LoopBuilder, 4> loops;
 };
 
 /// Helper class to sugar building loop.for loop nests from ranges.
 /// This is similar to edsc::AffineLoopNestBuilder except it operates on
 /// loop.for.
 class LoopNestBuilder {
 public:
-  LoopNestBuilder(ValueHandle *iv, ValueHandle lb, ValueHandle ub,
-                  ValueHandle step,
-                  ArrayRef<ValueHandle *> iter_args_handles = {},
-                  ValueRange iter_args_init_values = {});
-  LoopNestBuilder(ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-                  ArrayRef<ValueHandle> ubs, ArrayRef<ValueHandle> steps);
+  LoopNestBuilder(Value *iv, Value lb, Value ub, Value step);
+  LoopNestBuilder(Value *iv, Value lb, Value ub, Value step,
+                  MutableArrayRef<Value> iterArgsHandles,
+                  ValueRange iterArgsInitValues);
+  LoopNestBuilder(MutableArrayRef<Value> ivs, ArrayRef<Value> lbs,
+                  ArrayRef<Value> ubs, ArrayRef<Value> steps);
   Operation::result_range operator()(std::function<void(void)> fun = nullptr);
 
 private:
   SmallVector<LoopBuilder, 4> loops;
 };
 
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LOOPOPS_EDSC_BUILDERS_H_

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

 
 namespace mlir {
 namespace edsc {
 
 /// Base class for MemRefBoundsCapture and VectorBoundsCapture.
 class BoundsCapture {
 public:
   unsigned rank() const { return lbs.size(); }
-  ValueHandle lb(unsigned idx) { return lbs[idx]; }
-  ValueHandle ub(unsigned idx) { return ubs[idx]; }
+  Value lb(unsigned idx) { return lbs[idx]; }
+  Value ub(unsigned idx) { return ubs[idx]; }
   int64_t step(unsigned idx) { return steps[idx]; }
-  std::tuple<ValueHandle, ValueHandle, int64_t> range(unsigned idx) {
+  std::tuple<Value, Value, int64_t> range(unsigned idx) {
     return std::make_tuple(lbs[idx], ubs[idx], steps[idx]);
   }
   void swapRanges(unsigned i, unsigned j) {
     if (i == j)
       return;
-    lbs[i].swap(lbs[j]);
-    ubs[i].swap(ubs[j]);
+    std::swap(lbs[i], lbs[j]);
+    std::swap(ubs[i], ubs[j]);
     std::swap(steps[i], steps[j]);
   }
 
-  ArrayRef<ValueHandle> getLbs() { return lbs; }
-  ArrayRef<ValueHandle> getUbs() { return ubs; }
+  ArrayRef<Value> getLbs() { return lbs; }
+  ArrayRef<Value> getUbs() { return ubs; }
   ArrayRef<int64_t> getSteps() { return steps; }
 
 protected:
-  SmallVector<ValueHandle, 8> lbs;
-  SmallVector<ValueHandle, 8> ubs;
+  SmallVector<Value, 8> lbs;
+  SmallVector<Value, 8> ubs;
   SmallVector<int64_t, 8> steps;
 };
 
 /// A MemRefBoundsCapture represents the information required to step through a
 /// MemRef. It has placeholders for non-contiguous tensors that fit within the
 /// Fortran subarray model.
 /// At the moment it can only capture a MemRef with an identity layout map.
 // TODO(ntv): Support MemRefs with layoutMaps.
 class MemRefBoundsCapture : public BoundsCapture {
 public:
   explicit MemRefBoundsCapture(Value v);
   MemRefBoundsCapture(const MemRefBoundsCapture &) = default;
   MemRefBoundsCapture &operator=(const MemRefBoundsCapture &) = default;
 
   unsigned fastestVarying() const { return rank() - 1; }
 
 private:
-  ValueHandle base;
+  Value base;
 };
 
 /// A VectorBoundsCapture represents the information required to step through a
 /// Vector accessing each scalar element at a time. It is the counterpart of
 /// a MemRefBoundsCapture but for vectors. This exists purely for boilerplate
 /// avoidance.
 class VectorBoundsCapture : public BoundsCapture {
 public:
   explicit VectorBoundsCapture(Value v);
   VectorBoundsCapture(const VectorBoundsCapture &) = default;
   VectorBoundsCapture &operator=(const VectorBoundsCapture &) = default;
 
 private:
-  ValueHandle base;
+  Value base;
 };
 
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_EDSC_BUILDERS_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 {
-namespace folded {
-/// Helper variadic abstraction to allow extending to any MLIR op without
-/// boilerplate or Tablegen.
-/// Arguably a builder is not a ValueHandle but in practice it is only used as
-/// an alias to a notional ValueHandle<Op>.
-/// Implementing it as a subclass allows it to compose all the way to Value.
-/// Without subclassing, implicit conversion to Value would fail when composing
-/// in patterns such as: `select(a, b, select(c, d, e))`.
-template <typename Op>
-struct ValueBuilder : public ValueHandle {
-  /// Folder-based
-  template <typename... Args>
-  ValueBuilder(OperationFolder *folder, Args... args)
-      : ValueHandle(ValueHandle::create<Op>(folder, detail::unpack(args)...)) {}
-  ValueBuilder(OperationFolder *folder, ArrayRef<ValueHandle> vs)
-      : ValueBuilder(ValueBuilder::create<Op>(folder, detail::unpack(vs))) {}
-  template <typename... Args>
-  ValueBuilder(OperationFolder *folder, ArrayRef<ValueHandle> vs, Args... args)
-      : ValueHandle(ValueHandle::create<Op>(folder, detail::unpack(vs),
-                                            detail::unpack(args)...)) {}
-  template <typename T, typename... Args>
-  ValueBuilder(OperationFolder *folder, T t, ArrayRef<ValueHandle> vs,
-               Args... args)
-      : ValueHandle(ValueHandle::create<Op>(folder, detail::unpack(t),
-                                            detail::unpack(vs),
-                                            detail::unpack(args)...)) {}
-  template <typename T1, typename T2, typename... Args>
-  ValueBuilder(OperationFolder *folder, T1 t1, T2 t2, ArrayRef<ValueHandle> vs,
-               Args... args)
-      : ValueHandle(ValueHandle::create<Op>(
-            folder, detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
-            detail::unpack(args)...)) {}
-};
-} // namespace folded
 
 using std_addf = ValueBuilder<AddFOp>;
 using std_alloc = ValueBuilder<AllocOp>;
 using std_call = OperationBuilder<CallOp>;
 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_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<ValueHandle> operands);
+OperationHandle std_br(BlockHandle bh, ArrayRef<Value> 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<ValueHandle *> captures,
-                       ArrayRef<ValueHandle> operands);
+OperationHandle std_br(BlockHandle *bh, ArrayRef<Type> types,
+                       MutableArrayRef<Value> captures,
+                       ArrayRef<Value> 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(ValueHandle cond, BlockHandle trueBranch,
-                            ArrayRef<ValueHandle> trueOperands,
+OperationHandle std_cond_br(Value cond, BlockHandle trueBranch,
+                            ArrayRef<Value> trueOperands,
                             BlockHandle falseBranch,
-                            ArrayRef<ValueHandle> falseOperands);
+                            ArrayRef<Value> 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(ValueHandle cond, BlockHandle *trueBranch,
-                            ArrayRef<ValueHandle *> trueCaptures,
-                            ArrayRef<ValueHandle> trueOperands,
-                            BlockHandle *falseBranch,
-                            ArrayRef<ValueHandle *> falseCaptures,
-                            ArrayRef<ValueHandle> falseOperands);
+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);
 
 /// Provide an index notation around sdt_load and std_store.
 using StdIndexedValue =
     TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
-
-using folded_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
-using folded_std_constant_float = folded::ValueBuilder<ConstantFloatOp>;
-using folded_std_constant_int = folded::ValueBuilder<ConstantIntOp>;
-using folded_std_constant = folded::ValueBuilder<ConstantOp>;
-using folded_std_dim = folded::ValueBuilder<DimOp>;
-using folded_std_muli = folded::ValueBuilder<MulIOp>;
-using folded_std_addi = folded::ValueBuilder<AddIOp>;
-using folded_std_addf = folded::ValueBuilder<AddFOp>;
-using folded_std_alloc = folded::ValueBuilder<AllocOp>;
-using folded_std_constant = folded::ValueBuilder<ConstantOp>;
-using folded_std_constant_float = folded::ValueBuilder<ConstantFloatOp>;
-using folded_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
-using folded_std_constant_int = folded::ValueBuilder<ConstantIntOp>;
-using folded_std_dim = folded::ValueBuilder<DimOp>;
-using folded_std_extract_element = folded::ValueBuilder<ExtractElementOp>;
-using folded_std_index_cast = folded::ValueBuilder<IndexCastOp>;
-using folded_std_muli = folded::ValueBuilder<MulIOp>;
-using folded_std_mulf = folded::ValueBuilder<MulFOp>;
-using folded_std_memref_cast = folded::ValueBuilder<MemRefCastOp>;
-using folded_std_select = folded::ValueBuilder<SelectOp>;
-using folded_std_load = folded::ValueBuilder<LoadOp>;
-using folded_std_subi = folded::ValueBuilder<SubIOp>;
-using folded_std_sub_view = folded::ValueBuilder<SubViewOp>;
-using folded_std_tanh = folded::ValueBuilder<TanhOp>;
-using folded_std_tensor_load = folded::ValueBuilder<TensorLoadOp>;
-using folded_std_view = folded::ValueBuilder<ViewOp>;
-using folded_std_zero_extendi = folded::ValueBuilder<ZeroExtendIOp>;
-using folded_std_sign_extendi = folded::ValueBuilder<SignExtendIOp>;
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

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

 namespace mlir {
 namespace edsc {
 namespace intrinsics {
 
 using vector_broadcast = ValueBuilder<vector::BroadcastOp>;
 using vector_contract = ValueBuilder<vector::ContractionOp>;
 using vector_matmul = ValueBuilder<vector::MatmulOp>;
 using vector_print = OperationBuilder<vector::PrintOp>;
+using vector_type_cast = ValueBuilder<vector::TypeCastOp>;
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_EDSC_INTRINSICS_H_

mlir/include/mlir/EDSC/Builders.h

 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 
 namespace mlir {
 class OperationFolder;
 
 namespace edsc {
 class BlockHandle;
-class CapturableHandle;
 class NestedBuilder;
-class ValueHandle;
 
 /// Helper class to transparently handle builder insertion points by RAII.
 /// As its name indicates, a ScopedContext is means to be used locally in a
 /// scoped fashion. This abstracts away all the boilerplate related to
 /// checking proper usage of captures, NestedBuilders as well as handling the
 /// setting and restoring of insertion points.
 class ScopedContext {
 public:
private:
   Optional<OpBuilder::InsertPoint> prevBuilderInsertPoint;
   /// Current location.
   Location location;
   /// Parent context we return into.
   ScopedContext *enclosingScopedContext;
   /// Defensively keeps track of the current NestedBuilder to ensure proper
   /// scoping usage.
   NestedBuilder *nestedBuilder;
+};
 
-  // TODO: Implement scoping of ValueHandles. To do this we need a proper data
-  // structure to hold ValueHandle objects. We can emulate one but there should
-  // already be something available in LLVM for this purpose.
+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);
+  }
+
+  operator Value() { return value; }
+  Value value;
 };
 
 /// 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 of type ValueHandle and
-/// BlockHandle.
+/// from declaration (in a PL sense) on placeholders.
 class NestedBuilder {
 protected:
   NestedBuilder() = default;
   NestedBuilder(const NestedBuilder &) = delete;
   NestedBuilder(NestedBuilder &&other) : bodyScope(other.bodyScope) {
     other.bodyScope = nullptr;
   }
 
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(ValueHandle *iv,
-                                           ArrayRef<ValueHandle> lbHandles,
-                                           ArrayRef<ValueHandle> ubHandles,
+  friend LoopBuilder makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbHandles,
+                                           ArrayRef<Value> ubHandles,
                                            int64_t step);
-  friend LoopBuilder makeParallelLoopBuilder(ArrayRef<ValueHandle *> ivs,
-                                             ArrayRef<ValueHandle> lbHandles,
-                                             ArrayRef<ValueHandle> ubHandles,
-                                             ArrayRef<ValueHandle> steps);
-  friend LoopBuilder makeLoopBuilder(ValueHandle *iv, ValueHandle lbHandle,
-                                     ValueHandle ubHandle,
-                                     ValueHandle stepHandle,
-                                     ArrayRef<ValueHandle *> iter_args_handles,
-                                     ValueRange iter_args_init_values);
+  friend LoopBuilder makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
+                                             ArrayRef<Value> lbHandles,
+                                             ArrayRef<Value> ubHandles,
+                                             ArrayRef<Value> steps);
+  friend LoopBuilder makeLoopBuilder(Value *iv, Value lbHandle, Value ubHandle,
+                                     Value stepHandle,
+                                     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 {};
 
 /// A BlockBuilder is a NestedBuilder for mlir::Block*.
 /// This exists by opposition to LoopBuilder which is not related to an
 /// mlir::Block* but to a mlir::Value.
 /// It is meant to be used as a temporary object for representing any nested
 /// MLIR construct that is "related to" an mlir::Block*.
 class BlockBuilder : public NestedBuilder {
 public:
   /// Enters the mlir::Block* previously captured by `bh` and sets the insertion
   /// point to its end.
   BlockBuilder(BlockHandle bh, Append);
 
   /// Constructs a new mlir::Block with argument types derived from `args`.
   /// Captures the new block in `bh` and its arguments into `args`.
   /// Enters the new mlir::Block* and sets the insertion point to its end.
   ///
   /// Prerequisites:
-  ///   The ValueHandle `args` are typed delayed ValueHandles; i.e. they are
+  ///   The Value `args` are typed delayed Values; i.e. they are
   ///   not yet bound to mlir::Value.
-  BlockBuilder(BlockHandle *bh, ArrayRef<ValueHandle *> args);
+  BlockBuilder(BlockHandle *bh) : BlockBuilder(bh, {}, {}) {}
+  BlockBuilder(BlockHandle *bh, ArrayRef<Type> types,
+               MutableArrayRef<Value> args);
 
   /// Constructs a new mlir::Block with argument types derived from `args` and
   /// appends it as the last block in the region.
   /// Captures the new block in `bh` and its arguments into `args`.
   /// Enters the new mlir::Block* and sets the insertion point to its end.
   ///
   /// Prerequisites:
-  ///   The ValueHandle `args` are typed delayed ValueHandles; i.e. they are
+  ///   The Value `args` are typed delayed Values; i.e. they are
   ///   not yet bound to mlir::Value.
-  BlockBuilder(BlockHandle *bh, Region &region, ArrayRef<ValueHandle *> args);
+  BlockBuilder(BlockHandle *bh, Region &region, ArrayRef<Type> types,
+               MutableArrayRef<Value> args);
 
   /// The only purpose of this operator is to serve as a sequence point so that
   /// the evaluation of `fun` (which build IR snippets in a scoped fashion) is
   /// scoped within a BlockBuilder.
   void operator()(function_ref<void(void)> fun = nullptr);
 
 private:
   BlockBuilder(BlockBuilder &) = delete;
   BlockBuilder &operator=(BlockBuilder &other) = delete;
 };
 
-/// Base class for ValueHandle, OperationHandle and BlockHandle.
+/// Base class for Value, OperationHandle and BlockHandle.
 /// Not meant to be used outside of these classes.
 class CapturableHandle {
 protected:
   CapturableHandle() = default;
 };
 
-/// ValueHandle implements a (potentially "delayed") typed Value abstraction.
-/// ValueHandle should be captured by pointer but otherwise passed by Value
-/// everywhere.
-/// A ValueHandle can have 3 states:
-///   1. null state (empty type and empty value), in which case it does not hold
-///      a value and must never hold a Value (now or in the future). This is
-///      used for MLIR operations with zero returns as well as the result of
-///      calling a NestedBuilder::operator(). In both cases the objective is to
-///      have an object that can be inserted in an ArrayRef<ValueHandle> to
-///      implement nesting;
-///   2. delayed state (empty value), in which case it represents an eagerly
-///      typed "delayed" value that can be hold a Value in the future;
-///   3. constructed state,in which case it holds a Value.
-///
-/// A ValueHandle is meant to capture a single Value and should be used for
-/// operations that have a single result. For convenience of use, we also
-/// include AffineForOp in this category although it does not return a value.
-/// In the case of AffineForOp, the captured Value is the loop induction
-/// variable.
-class ValueHandle : public CapturableHandle {
-public:
-  /// A ValueHandle in a null state can never be captured;
-  static ValueHandle null() { return ValueHandle(); }
-
-  /// A ValueHandle that is constructed from a Type represents a typed "delayed"
-  /// Value. A delayed Value can only capture Values of the specified type.
-  /// Such a delayed value represents the declaration (in the PL sense) of a
-  /// placeholder for an mlir::Value that will be constructed and captured at
-  /// some later point in the program.
-  explicit ValueHandle(Type t) : t(t), v(nullptr) {}
-
-  /// A ValueHandle that is constructed from an mlir::Value is an "eager"
-  /// Value. An eager Value represents both the declaration and the definition
-  /// (in the PL sense) of a placeholder for an mlir::Value that has already
-  /// been constructed in the past and that is captured "now" in the program.
-  explicit ValueHandle(Value v) : t(v.getType()), v(v) {}
-
-  /// ValueHandle is a value type, use the default copy constructor.
-  ValueHandle(const ValueHandle &other) = default;
-
-  /// ValueHandle is a value type, the assignment operator typechecks before
-  /// assigning.
-  ValueHandle &operator=(const ValueHandle &other);
-
-  /// Provide a swap operator.
-  void swap(ValueHandle &other) {
-    if (this == &other)
-      return;
-    std::swap(t, other.t);
-    std::swap(v, other.v);
-  }
-
-  /// Implicit conversion useful for automatic conversion to Container<Value>.
-  operator Value() const { return getValue(); }
-  operator Type() const { return getType(); }
-  operator bool() const { return hasValue(); }
-
-  /// 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 ValueHandle create(Args... args);
-
-  /// 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.
-  /// When non-null, the optional pointer `folder` is used to call into the
-  /// `createAndFold` builder method. If `folder` is null, the regular `create`
-  /// method is called.
-  template <typename Op, typename... Args>
-  static ValueHandle create(OperationFolder *folder, Args... args);
-
-  /// Generic create for a named operation producing a single value.
-  static ValueHandle create(StringRef name, ArrayRef<ValueHandle> operands,
-                            ArrayRef<Type> resultTypes,
-                            ArrayRef<NamedAttribute> attributes = {});
-
-  bool hasValue() const { return v != nullptr; }
-  Value getValue() const {
-    assert(hasValue() && "Unexpected null value;");
-    return v;
-  }
-  bool hasType() const { return t != Type(); }
-  Type getType() const { return t; }
-
-  Operation *getOperation() const {
-    if (!v)
-      return nullptr;
-    return v.getDefiningOp();
-  }
-
-  // Return a vector of fresh ValueHandles that have not captured.
-  static SmallVector<ValueHandle, 8> makeIndexHandles(unsigned count) {
-    auto indexType = IndexType::get(ScopedContext::getContext());
-    return SmallVector<ValueHandle, 8>(count, ValueHandle(indexType));
-  }
-
-protected:
-  ValueHandle() : t(), v(nullptr) {}
-
-  Type t;
-  Value v;
-};
-
-/// An OperationHandle can be used in lieu of ValueHandle to capture the
+/// 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 ValueHandle.
+/// 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<ValueHandle> operands,
+  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;
 };
 
-/// Simple wrapper to build a generic operation without successor blocks.
-template <typename HandleType>
-struct CustomOperation {
-  CustomOperation(StringRef name) : name(name) {
-    static_assert(std::is_same<HandleType, ValueHandle>() ||
-                      std::is_same<HandleType, OperationHandle>(),
-                  "Only CustomOperation<ValueHandle> or "
-                  "CustomOperation<OperationHandle> can be constructed.");
-  }
-  HandleType operator()(ArrayRef<ValueHandle> operands = {},
-                        ArrayRef<Type> resultTypes = {},
-                        ArrayRef<NamedAttribute> attributes = {}) {
-    return HandleType::create(name, operands, resultTypes, attributes);
-  }
-  std::string name;
-};
-
 /// 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 {
 public:
   /// A BlockHandle constructed without an mlir::Block* represents a "delayed"

 /// A StructuredIndexed itself is indexed and passed to `makeGenericLinalgOp`.
 /// It enable an idiomatic syntax for index expressions such as:
 ///
 /// ```
 ///      StructuredIndexed A(buffer_or_tensor_value), B(buffer_or_tensor_value),
 ///        C(buffer_value_or_tensor_type);
 ///      makeGenericLinalgOp({A({m, n}), B({k, n})}, {C({m, n})}, ... );
 /// ```
-struct StructuredIndexed : public ValueHandle {
-  StructuredIndexed(Type type) : ValueHandle(type) {}
-  StructuredIndexed(Value value) : ValueHandle(value) {}
-  StructuredIndexed(ValueHandle valueHandle) : ValueHandle(valueHandle) {}
+struct StructuredIndexed {
+  StructuredIndexed(Value v) : value(v) {}
+  StructuredIndexed(Type t) : type(t) {}
   StructuredIndexed operator()(ArrayRef<AffineExpr> indexings) {
-    return this->hasValue() ? StructuredIndexed(this->getValue(), indexings)
-                            : StructuredIndexed(this->getType(), indexings);
+    return value ? StructuredIndexed(value, indexings)
+                 : StructuredIndexed(type, indexings);
   }
 
-  StructuredIndexed(Type t, ArrayRef<AffineExpr> indexings)
-      : ValueHandle(t), exprs(indexings.begin(), indexings.end()) {
-    assert(t.isa<RankedTensorType>() && "RankedTensor expected");
-  }
   StructuredIndexed(Value v, ArrayRef<AffineExpr> indexings)
-      : ValueHandle(v), exprs(indexings.begin(), indexings.end()) {
+      : value(v), exprs(indexings.begin(), indexings.end()) {
     assert((v.getType().isa<MemRefType>() ||
             v.getType().isa<RankedTensorType>() ||
             v.getType().isa<VectorType>()) &&
            "MemRef, RankedTensor or Vector expected");
   }
-  StructuredIndexed(ValueHandle vh, ArrayRef<AffineExpr> indexings)
-      : ValueHandle(vh), exprs(indexings.begin(), indexings.end()) {}
+  StructuredIndexed(Type t, ArrayRef<AffineExpr> indexings)
+      : type(t), exprs(indexings.begin(), indexings.end()) {
+    assert((t.isa<MemRefType>() || t.isa<RankedTensorType>() ||
+            t.isa<VectorType>()) &&
+           "MemRef, RankedTensor or Vector expected");
+  }
 
-  ArrayRef<AffineExpr> getExprs() { return exprs; }
+  bool hasValue() const { return value; }
+  Value getValue() const {
+    assert(value && "StructuredIndexed Value not set.");
+    return value;
+  }
+  Type getType() const {
+    assert((value || type) && "StructuredIndexed Value and Type not set.");
+    return value ? value.getType() : type;
+  }
+  ArrayRef<AffineExpr> getExprs() const { return exprs; }
+  operator Value() const { return getValue(); }
+  operator Type() const { return getType(); }
 
 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());
 }
 
-template <typename Op, typename... Args>
-ValueHandle ValueHandle::create(Args... args) {
-  Operation *op = ScopedContext::getBuilder()
-                      .create<Op>(ScopedContext::getLocation(), args...)
-                      .getOperation();
-  if (op->getNumResults() == 1)
-    return ValueHandle(op->getResult(0));
-  llvm_unreachable("unsupported operation, use an OperationHandle instead");
-}
-
-/// Entry point to build multiple ValueHandle from a `Container` of Value or
-/// Type.
-template <typename Container>
-inline SmallVector<ValueHandle, 8> makeValueHandles(Container values) {
-  SmallVector<ValueHandle, 8> res;
-  res.reserve(values.size());
-  for (auto v : values)
-    res.push_back(ValueHandle(v));
-  return res;
-}
-
 /// 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 ValueHandle emits an actual
+/// operation, while converting an IndexedValue to a Value emits an actual
 /// `Load` operation.
 template <typename Load, typename Store>
 class TemplatedIndexedValue {
 public:
-  explicit TemplatedIndexedValue(Type t) : base(t) {}
-  explicit TemplatedIndexedValue(Value v)
-      : TemplatedIndexedValue(ValueHandle(v)) {}
-  explicit TemplatedIndexedValue(ValueHandle v) : base(v) {}
+  explicit TemplatedIndexedValue(Value v) : value(v) {}
 
   TemplatedIndexedValue(const TemplatedIndexedValue &rhs) = default;
 
   TemplatedIndexedValue operator()() { return *this; }
   /// Returns a new `TemplatedIndexedValue`.
-  TemplatedIndexedValue operator()(ValueHandle index) {
-    TemplatedIndexedValue res(base);
+  TemplatedIndexedValue operator()(Value index) {
+    TemplatedIndexedValue res(value);
     res.indices.push_back(index);
     return res;
   }
   template <typename... Args>
-  TemplatedIndexedValue operator()(ValueHandle index, Args... indices) {
-    return TemplatedIndexedValue(base, index).append(indices...);
+  TemplatedIndexedValue operator()(Value index, Args... indices) {
+    return TemplatedIndexedValue(value, index).append(indices...);
   }
-  TemplatedIndexedValue operator()(ArrayRef<ValueHandle> indices) {
-    return TemplatedIndexedValue(base, indices);
+  TemplatedIndexedValue operator()(ArrayRef<Value> indices) {
+    return TemplatedIndexedValue(value, indices);
   }
 
   /// Emits a `store`.
   OperationHandle operator=(const TemplatedIndexedValue &rhs) {
-    ValueHandle rrhs(rhs);
-    return Store(rrhs, getBase(), {indices.begin(), indices.end()});
-  }
-  OperationHandle operator=(ValueHandle rhs) {
-    return Store(rhs, getBase(), {indices.begin(), indices.end()});
-  }
-
-  /// Emits a `load` when converting to a ValueHandle.
-  operator ValueHandle() const {
-    return Load(getBase(), {indices.begin(), indices.end()});
+    return Store(rhs, value, indices);
   }
+  OperationHandle operator=(Value rhs) { return Store(rhs, value, indices); }
 
   /// Emits a `load` when converting to a Value.
-  Value operator*(void)const {
-    return Load(getBase(), {indices.begin(), indices.end()}).getValue();
-  }
+  operator Value() const { return Load(value, indices); }
 
-  ValueHandle getBase() const { return base; }
+  Value getBase() const { return value; }
 
   /// Arithmetic operator overloadings.
-  ValueHandle operator+(ValueHandle e);
-  ValueHandle operator-(ValueHandle e);
-  ValueHandle operator*(ValueHandle e);
-  ValueHandle operator/(ValueHandle e);
-  ValueHandle operator%(ValueHandle e);
-  ValueHandle operator^(ValueHandle e);
-  ValueHandle operator+(TemplatedIndexedValue e) {
-    return *this + static_cast<ValueHandle>(e);
-  }
-  ValueHandle operator-(TemplatedIndexedValue e) {
-    return *this - static_cast<ValueHandle>(e);
-  }
-  ValueHandle operator*(TemplatedIndexedValue e) {
-    return *this * static_cast<ValueHandle>(e);
+  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) {
+    return *this + static_cast<Value>(e);
+  }
+  Value operator-(TemplatedIndexedValue e) {
+    return *this - static_cast<Value>(e);
+  }
+  Value operator*(TemplatedIndexedValue e) {
+    return *this * static_cast<Value>(e);
   }
-  ValueHandle operator/(TemplatedIndexedValue e) {
-    return *this / static_cast<ValueHandle>(e);
+  Value operator/(TemplatedIndexedValue e) {
+    return *this / static_cast<Value>(e);
   }
-  ValueHandle operator%(TemplatedIndexedValue e) {
-    return *this % static_cast<ValueHandle>(e);
+  Value operator%(TemplatedIndexedValue e) {
+    return *this % static_cast<Value>(e);
   }
-  ValueHandle operator^(TemplatedIndexedValue e) {
-    return *this ^ static_cast<ValueHandle>(e);
+  Value operator^(TemplatedIndexedValue e) {
+    return *this ^ static_cast<Value>(e);
   }
 
   /// Assignment-arithmetic operator overloadings.
-  OperationHandle operator+=(ValueHandle e);
-  OperationHandle operator-=(ValueHandle e);
-  OperationHandle operator*=(ValueHandle e);
-  OperationHandle operator/=(ValueHandle e);
-  OperationHandle operator%=(ValueHandle e);
-  OperationHandle operator^=(ValueHandle e);
+  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) {
-    return this->operator+=(static_cast<ValueHandle>(e));
+    return this->operator+=(static_cast<Value>(e));
   }
   OperationHandle operator-=(TemplatedIndexedValue e) {
-    return this->operator-=(static_cast<ValueHandle>(e));
+    return this->operator-=(static_cast<Value>(e));
   }
   OperationHandle operator*=(TemplatedIndexedValue e) {
-    return this->operator*=(static_cast<ValueHandle>(e));
+    return this->operator*=(static_cast<Value>(e));
   }
   OperationHandle operator/=(TemplatedIndexedValue e) {
-    return this->operator/=(static_cast<ValueHandle>(e));
+    return this->operator/=(static_cast<Value>(e));
   }
   OperationHandle operator%=(TemplatedIndexedValue e) {
-    return this->operator%=(static_cast<ValueHandle>(e));
+    return this->operator%=(static_cast<Value>(e));
   }
   OperationHandle operator^=(TemplatedIndexedValue e) {
-    return this->operator^=(static_cast<ValueHandle>(e));
+    return this->operator^=(static_cast<Value>(e));
   }
 
   /// Logical operator overloadings.
-  ValueHandle operator&&(ValueHandle e);
-  ValueHandle operator||(ValueHandle e);
-  ValueHandle operator&&(TemplatedIndexedValue e) {
-    return *this && static_cast<ValueHandle>(e);
+  Value operator&&(Value e);
+  Value operator||(Value e);
+  Value operator&&(TemplatedIndexedValue e) {
+    return *this && static_cast<Value>(e);
   }
-  ValueHandle operator||(TemplatedIndexedValue e) {
-    return *this || static_cast<ValueHandle>(e);
+  Value operator||(TemplatedIndexedValue e) {
+    return *this || static_cast<Value>(e);
   }
 
   /// Comparison operator overloadings.
-  ValueHandle operator==(ValueHandle e);
-  ValueHandle operator!=(ValueHandle e);
-  ValueHandle operator<(ValueHandle e);
-  ValueHandle operator<=(ValueHandle e);
-  ValueHandle operator>(ValueHandle e);
-  ValueHandle operator>=(ValueHandle e);
-  ValueHandle operator==(TemplatedIndexedValue e) {
-    return *this == static_cast<ValueHandle>(e);
-  }
-  ValueHandle operator!=(TemplatedIndexedValue e) {
-    return *this != static_cast<ValueHandle>(e);
-  }
-  ValueHandle operator<(TemplatedIndexedValue e) {
-    return *this < static_cast<ValueHandle>(e);
+  Value eq(Value e);
+  Value ne(Value e);
+  Value operator<(Value e);
+  Value operator<=(Value e);
+  Value operator>(Value e);
+  Value operator>=(Value e);
+  Value operator<(TemplatedIndexedValue e) {
+    return *this < static_cast<Value>(e);
   }
-  ValueHandle operator<=(TemplatedIndexedValue e) {
-    return *this <= static_cast<ValueHandle>(e);
+  Value operator<=(TemplatedIndexedValue e) {
+    return *this <= static_cast<Value>(e);
   }
-  ValueHandle operator>(TemplatedIndexedValue e) {
-    return *this > static_cast<ValueHandle>(e);
+  Value operator>(TemplatedIndexedValue e) {
+    return *this > static_cast<Value>(e);
   }
-  ValueHandle operator>=(TemplatedIndexedValue e) {
-    return *this >= static_cast<ValueHandle>(e);
+  Value operator>=(TemplatedIndexedValue e) {
+    return *this >= static_cast<Value>(e);
   }
 
 private:
-  TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices)
-      : base(base), indices(indices.begin(), indices.end()) {}
+  TemplatedIndexedValue(Value value, ArrayRef<Value> indices)
+      : value(value), indices(indices.begin(), indices.end()) {}
 
   TemplatedIndexedValue &append() { return *this; }
 
   template <typename T, typename... Args>
   TemplatedIndexedValue &append(T index, Args... indices) {
-    this->indices.push_back(static_cast<ValueHandle>(index));
+    this->indices.push_back(static_cast<Value>(index));
     append(indices...);
     return *this;
   }
-  ValueHandle base;
-  SmallVector<ValueHandle, 8> indices;
+  Value value;
+  SmallVector<Value, 8> indices;
 };
 
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_EDSC_BUILDERS_H_

mlir/include/mlir/EDSC/Intrinsics.h

 
 namespace mlir {
 
 class MemRefType;
 class Type;
 
 namespace edsc {
 
-/// Entry point to build multiple ValueHandle* from a mutable list `ivs`.
-inline SmallVector<ValueHandle *, 8>
-makeHandlePointers(MutableArrayRef<ValueHandle> ivs) {
-  SmallVector<ValueHandle *, 8> pivs;
-  pivs.reserve(ivs.size());
-  for (auto &iv : ivs)
-    pivs.push_back(&iv);
-  return pivs;
-}
-
 /// 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 {
-namespace detail {
-/// Helper structure to be used with ValueBuilder / OperationBuilder.
-/// It serves the purpose of removing boilerplate specialization for the sole
-/// purpose of implicitly converting ArrayRef<ValueHandle> -> ArrayRef<Value>.
-class ValueHandleArray {
-public:
-  ValueHandleArray(ArrayRef<ValueHandle> vals) {
-    values.append(vals.begin(), vals.end());
-  }
-  operator ArrayRef<Value>() { return values; }
-
-private:
-  ValueHandleArray() = default;
-  SmallVector<Value, 8> values;
-};
-
-template <typename T>
-inline T unpack(T value) {
-  return value;
-}
-
-inline detail::ValueHandleArray unpack(ArrayRef<ValueHandle> values) {
-  return detail::ValueHandleArray(values);
-}
-
-} // namespace detail
-
-/// Helper variadic abstraction to allow extending to any MLIR op without
-/// boilerplate or Tablegen.
-/// Arguably a builder is not a ValueHandle but in practice it is only used as
-/// an alias to a notional ValueHandle<Op>.
-/// Implementing it as a subclass allows it to compose all the way to Value.
-/// Without subclassing, implicit conversion to Value would fail when composing
-/// in patterns such as: `select(a, b, select(c, d, e))`.
-template <typename Op>
-struct ValueBuilder : public ValueHandle {
-  // Builder-based
-  template <typename... Args>
-  ValueBuilder(Args... args)
-      : ValueHandle(ValueHandle::create<Op>(detail::unpack(args)...)) {}
-  ValueBuilder(ArrayRef<ValueHandle> vs)
-      : ValueBuilder(ValueBuilder::create<Op>(detail::unpack(vs))) {}
-  template <typename... Args>
-  ValueBuilder(ArrayRef<ValueHandle> vs, Args... args)
-      : ValueHandle(ValueHandle::create<Op>(detail::unpack(vs),
-                                            detail::unpack(args)...)) {}
-  template <typename T, typename... Args>
-  ValueBuilder(T t, ArrayRef<ValueHandle> vs, Args... args)
-      : ValueHandle(ValueHandle::create<Op>(
-            detail::unpack(t), detail::unpack(vs), detail::unpack(args)...)) {}
-  template <typename T1, typename T2, typename... Args>
-  ValueBuilder(T1 t1, T2 t2, ArrayRef<ValueHandle> vs, Args... args)
-      : ValueHandle(ValueHandle::create<Op>(
-            detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
-            detail::unpack(args)...)) {}
-
-  ValueBuilder() : ValueHandle(ValueHandle::create<Op>()) {}
-};
 
 template <typename Op>
 struct OperationBuilder : public OperationHandle {
   template <typename... Args>
   OperationBuilder(Args... args)
-      : OperationHandle(OperationHandle::create<Op>(detail::unpack(args)...)) {}
-  OperationBuilder(ArrayRef<ValueHandle> vs)
-      : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs))) {}
+      : OperationHandle(OperationHandle::create<Op>(args...)) {}
+  OperationBuilder(ArrayRef<Value> vs)
+      : OperationHandle(OperationHandle::create<Op>(vs)) {}
   template <typename... Args>
-  OperationBuilder(ArrayRef<ValueHandle> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs),
-                                                    detail::unpack(args)...)) {}
+  OperationBuilder(ArrayRef<Value> vs, Args... args)
+      : OperationHandle(OperationHandle::create<Op>(vs, args...)) {}
   template <typename T, typename... Args>
-  OperationBuilder(T t, ArrayRef<ValueHandle> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(
-            detail::unpack(t), detail::unpack(vs), detail::unpack(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<ValueHandle> vs, Args... args)
-      : OperationHandle(OperationHandle::create<Op>(
-            detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
-            detail::unpack(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/VectorToLoops/ConvertVectorToLoops.cpp

 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h"
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/LoopOps/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
+#include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/Types.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using vector::TransferReadOp;
 using vector::TransferWriteOp;
 
 /// Analyzes the `transfer` to find an access dimension along the fastest remote
 /// MemRef dimension. If such a dimension with coalescing properties is found,
 /// `pivs` and `vectorBoundsCapture` are swapped so that the invocation of
 /// LoopNestBuilder captures it in the innermost loop.
 template <typename TransferOpTy>
-static void coalesceCopy(TransferOpTy transfer,
-                         SmallVectorImpl<ValueHandle *> *pivs,
-                         VectorBoundsCapture *vectorBoundsCapture) {
+static int computeCoalescedIndex(TransferOpTy transfer) {
   // rank of the remote memory access, coalescing behavior occurs on the
   // innermost memory dimension.
   auto remoteRank = transfer.getMemRefType().getRank();
   // Iterate over the results expressions of the permutation map to determine
   // the loop order for creating pointwise copies between remote and local
   // memories.
   int coalescedIdx = -1;
   auto exprs = transfer.permutation_map().getResults();
   for (auto en : llvm::enumerate(exprs)) {
     auto dim = en.value().template dyn_cast<AffineDimExpr>();
     if (!dim) {
       continue;
     }
     auto memRefDim = dim.getPosition();
     if (memRefDim == remoteRank - 1) {
       // memRefDim has coalescing properties, it should be swapped in the last
       // position.
       assert(coalescedIdx == -1 && "Unexpected > 1 coalesced indices");
       coalescedIdx = en.index();
     }
   }
-  if (coalescedIdx >= 0) {
-    std::swap(pivs->back(), (*pivs)[coalescedIdx]);
-    vectorBoundsCapture->swapRanges(pivs->size() - 1, coalescedIdx);
-  }
+  return coalescedIdx;
 }
 
 /// Emits remote memory accesses that are clipped to the boundaries of the
 /// MemRef.
 template <typename TransferOpTy>
-static SmallVector<ValueHandle, 8> clip(TransferOpTy transfer,
-                                        MemRefBoundsCapture &bounds,
-                                        ArrayRef<ValueHandle> ivs) {
+static SmallVector<Value, 8>
+clip(TransferOpTy transfer, MemRefBoundsCapture &bounds, ArrayRef<Value> ivs) {
   using namespace mlir::edsc;
 
-  ValueHandle zero(std_constant_index(0)), one(std_constant_index(1));
-  SmallVector<ValueHandle, 8> memRefAccess(transfer.indices());
-  auto clippedScalarAccessExprs =
-      ValueHandle::makeIndexHandles(memRefAccess.size());
+  Value zero(std_constant_index(0)), one(std_constant_index(1));
+  SmallVector<Value, 8> memRefAccess(transfer.indices());
+  SmallVector<Value, 8> clippedScalarAccessExprs(memRefAccess.size());
   // Indices accessing to remote memory are clipped and their expressions are
   // returned in clippedScalarAccessExprs.
   for (unsigned memRefDim = 0; memRefDim < clippedScalarAccessExprs.size();
        ++memRefDim) {
     // Linear search on a small number of entries.
     int loopIndex = -1;
     auto exprs = transfer.permutation_map().getResults();
     for (auto en : llvm::enumerate(exprs)) {
for (unsigned memRefDim = 0; memRefDim < clippedScalarAccessExprs.size();
     }
   }
 
   return clippedScalarAccessExprs;
 }
 
 namespace {
 
-using vector_type_cast = edsc::intrinsics::ValueBuilder<vector::TypeCastOp>;
-
 /// Implements lowering of TransferReadOp and TransferWriteOp to a
 /// proper abstraction for the hardware.
 ///
 /// For now, we only emit a simple loop nest that performs clipped pointwise
 /// copies from a remote to a locally allocated memory.
 ///
 /// Consider the case:
 ///
LogicalResult VectorTransferRewriter<TransferReadOp>::matchAndRewrite(
 
   TransferReadOp transfer = cast<TransferReadOp>(op);
 
   // 1. Setup all the captures.
   ScopedContext scope(rewriter, transfer.getLoc());
   StdIndexedValue remote(transfer.memref());
   MemRefBoundsCapture memRefBoundsCapture(transfer.memref());
   VectorBoundsCapture vectorBoundsCapture(transfer.vector());
-  auto ivs = ValueHandle::makeIndexHandles(vectorBoundsCapture.rank());
-  SmallVector<ValueHandle *, 8> pivs =
-      makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
-  coalesceCopy(transfer, &pivs, &vectorBoundsCapture);
+  int coalescedIdx = computeCoalescedIndex(transfer);
+  // Swap the vectorBoundsCapture which will reorder loop bounds.
+  if (coalescedIdx >= 0)
+    vectorBoundsCapture.swapRanges(vectorBoundsCapture.rank() - 1,
+                                   coalescedIdx);
 
   auto lbs = vectorBoundsCapture.getLbs();
   auto ubs = vectorBoundsCapture.getUbs();
-  SmallVector<ValueHandle, 8> steps;
+  SmallVector<Value, 8> steps;
   steps.reserve(vectorBoundsCapture.getSteps().size());
   for (auto step : vectorBoundsCapture.getSteps())
     steps.push_back(std_constant_index(step));
 
   // 2. Emit alloc-copy-load-dealloc.
-  ValueHandle tmp = std_alloc(tmpMemRefType(transfer));
+  Value tmp = std_alloc(tmpMemRefType(transfer));
   StdIndexedValue local(tmp);
-  ValueHandle vec = vector_type_cast(tmp);
-  LoopNestBuilder(pivs, lbs, ubs, steps)([&] {
+  Value vec = vector_type_cast(tmp);
+  SmallVector<Value, 8> ivs(lbs.size());
+  LoopNestBuilder(ivs, lbs, ubs, steps)([&] {
+    // Swap the ivs which will reorder memory accesses.
+    if (coalescedIdx >= 0)
+      std::swap(ivs.back(), ivs[coalescedIdx]);
     // Computes clippedScalarAccessExprs in the loop nest scope (ivs exist).
     local(ivs) = remote(clip(transfer, memRefBoundsCapture, ivs));
   });
-  ValueHandle vectorValue = std_load(vec);
+  Value vectorValue = std_load(vec);
   (std_dealloc(tmp)); // vexing parse
 
   // 3. Propagate.
-  rewriter.replaceOp(op, vectorValue.getValue());
+  rewriter.replaceOp(op, vectorValue);
   return success();
 }
 
 /// Lowers TransferWriteOp into a combination of:
 ///   1. local memory allocation;
 ///   2. vector_store to local buffer (viewed as a memref<1 x vector>);
 ///   3. perfect loop nest over:
 ///      a. scalar load from local buffers (viewed as a scalar memref);
LogicalResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(
   using namespace edsc::op;
 
   TransferWriteOp transfer = cast<TransferWriteOp>(op);
 
   // 1. Setup all the captures.
   ScopedContext scope(rewriter, transfer.getLoc());
   StdIndexedValue remote(transfer.memref());
   MemRefBoundsCapture memRefBoundsCapture(transfer.memref());
-  ValueHandle vectorValue(transfer.vector());
+  Value vectorValue(transfer.vector());
   VectorBoundsCapture vectorBoundsCapture(transfer.vector());
-  auto ivs = ValueHandle::makeIndexHandles(vectorBoundsCapture.rank());
-  SmallVector<ValueHandle *, 8> pivs =
-      makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
-  coalesceCopy(transfer, &pivs, &vectorBoundsCapture);
+  int coalescedIdx = computeCoalescedIndex(transfer);
+  // Swap the vectorBoundsCapture which will reorder loop bounds.
+  if (coalescedIdx >= 0)
+    vectorBoundsCapture.swapRanges(vectorBoundsCapture.rank() - 1,
+                                   coalescedIdx);
 
   auto lbs = vectorBoundsCapture.getLbs();
   auto ubs = vectorBoundsCapture.getUbs();
-  SmallVector<ValueHandle, 8> steps;
+  SmallVector<Value, 8> steps;
   steps.reserve(vectorBoundsCapture.getSteps().size());
   for (auto step : vectorBoundsCapture.getSteps())
     steps.push_back(std_constant_index(step));
 
   // 2. Emit alloc-store-copy-dealloc.
-  ValueHandle tmp = std_alloc(tmpMemRefType(transfer));
+  Value tmp = std_alloc(tmpMemRefType(transfer));
   StdIndexedValue local(tmp);
-  ValueHandle vec = vector_type_cast(tmp);
+  Value vec = vector_type_cast(tmp);
   std_store(vectorValue, vec);
-  LoopNestBuilder(pivs, lbs, ubs, steps)([&] {
+  SmallVector<Value, 8> ivs(lbs.size());
+  LoopNestBuilder(ivs, lbs, ubs, steps)([&] {
+    // Swap the ivs which will reorder memory accesses.
+    if (coalescedIdx >= 0)
+      std::swap(ivs.back(), ivs[coalescedIdx]);
     // Computes clippedScalarAccessExprs in the loop nest scope (ivs exist).
     remote(clip(transfer, memRefBoundsCapture, ivs)) = local(ivs);
   });
   (std_dealloc(tmp)); // vexing parse...
 
   rewriter.eraseOp(op);
   return success();
 }
 
 } // namespace
 
 void mlir::populateVectorToAffineLoopsConversionPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns) {
   patterns.insert<VectorTransferRewriter<vector::TransferReadOp>,
                   VectorTransferRewriter<vector::TransferWriteOp>>(context);
 }

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

 //===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
 //
 // 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/Affine/EDSC/Builders.h"
 #include "mlir/Dialect/StandardOps/EDSC/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
-static Optional<ValueHandle> emitStaticFor(ArrayRef<ValueHandle> lbs,
-                                           ArrayRef<ValueHandle> ubs,
-                                           int64_t step) {
+static Optional<Value> emitStaticFor(ArrayRef<Value> lbs, ArrayRef<Value> ubs,
   if (lbs.size() != 1 || ubs.size() != 1)
-    return Optional<ValueHandle>();
+    return Optional<Value>();
 
-  auto *lbDef = lbs.front().getValue().getDefiningOp();
-  auto *ubDef = ubs.front().getValue().getDefiningOp();
+  auto *lbDef = lbs.front().getDefiningOp();
+  auto *ubDef = ubs.front().getDefiningOp();
   if (!lbDef || !ubDef)
-    return Optional<ValueHandle>();
+    return Optional<Value>();
 
   auto lbConst = dyn_cast<ConstantIndexOp>(lbDef);
   auto ubConst = dyn_cast<ConstantIndexOp>(ubDef);
   if (!lbConst || !ubConst)
-    return Optional<ValueHandle>();
-
-  return ValueHandle(ScopedContext::getBuilder()
-                         .create<AffineForOp>(ScopedContext::getLocation(),
-                                              lbConst.getValue(),
-                                              ubConst.getValue(), step)
-                         .getInductionVar());
+    return Optional<Value>();
+  return ScopedContext::getBuilder()
+      .create<AffineForOp>(ScopedContext::getLocation(), lbConst.getValue(),
+      .getInductionVar();
 }
 
-LoopBuilder mlir::edsc::makeAffineLoopBuilder(ValueHandle *iv,
-                                              ArrayRef<ValueHandle> lbHandles,
-                                              ArrayRef<ValueHandle> ubHandles,
+LoopBuilder mlir::edsc::makeAffineLoopBuilder(Value *iv, ArrayRef<Value> lbs,
+                                              ArrayRef<Value> ubs,
                                               int64_t step) {
   mlir::edsc::LoopBuilder result;
-  if (auto staticFor = emitStaticFor(lbHandles, ubHandles, step)) {
-    *iv = staticFor.getValue();
+  if (auto staticForIv = emitStaticFor(lbs, ubs, step)) {
+    *iv = staticForIv.getValue();
   } else {
-    SmallVector<Value, 4> lbs(lbHandles.begin(), lbHandles.end());
-    SmallVector<Value, 4> ubs(ubHandles.begin(), ubHandles.end());
     auto b = ScopedContext::getBuilder();
-    *iv = ValueHandle(
-        b.create<AffineForOp>(ScopedContext::getLocation(), lbs,
+    *iv =
+        Value(b.create<AffineForOp>(ScopedContext::getLocation(), lbs,
                                     b.getMultiDimIdentityMap(lbs.size()), ubs,
                                     b.getMultiDimIdentityMap(ubs.size()), step)
                   .getInductionVar());
   }
-  auto *body = getForInductionVarOwner(iv->getValue()).getBody();
+
+  auto *body = getForInductionVarOwner(*iv).getBody();
   result.enter(body, /*prev=*/1);
   return result;
 }
 
-mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
-    ValueHandle *iv, ArrayRef<ValueHandle> lbs, ArrayRef<ValueHandle> ubs,
+mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(Value *iv,
+                                                         ArrayRef<Value> lbs,
+                                                         ArrayRef<Value> ubs,
                                                          int64_t step) {
   loops.emplace_back(makeAffineLoopBuilder(iv, lbs, ubs, step));
 }
 
 mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-    ArrayRef<ValueHandle> ubs, ArrayRef<int64_t> steps) {
+    MutableArrayRef<Value> ivs, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
+    ArrayRef<int64_t> steps) {
   assert(ivs.size() == lbs.size() && "Mismatch in number of arguments");
   assert(ivs.size() == ubs.size() && "Mismatch in number of arguments");
   assert(ivs.size() == steps.size() && "Mismatch in number of arguments");
   for (auto it : llvm::zip(ivs, lbs, ubs, steps))
-    loops.emplace_back(makeAffineLoopBuilder(std::get<0>(it), std::get<1>(it),
+    loops.emplace_back(makeAffineLoopBuilder(&std::get<0>(it), std::get<1>(it),
                                              std::get<2>(it), std::get<3>(it)));
 }
 
 void mlir::edsc::AffineLoopNestBuilder::operator()(
     function_ref<void(void)> fun) {
   if (fun)
     fun();
   // Iterate on the calling operator() on all the loops in the nest.
   // The iteration order is from innermost to outermost because enter/exit needs
   // to be asymmetric (i.e. enter() occurs on LoopBuilder construction, exit()
   // occurs on calling operator()). The asymmetry is required for properly
   // nesting imperfectly nested regions (see LoopBuilder::operator()).
   for (auto lit = loops.rbegin(), eit = loops.rend(); lit != eit; ++lit)
     (*lit)();
 }
 
-template <typename Op>
-static ValueHandle createBinaryHandle(ValueHandle lhs, ValueHandle rhs) {
-  return ValueHandle::create<Op>(lhs.getValue(), rhs.getValue());
-}
-
 static std::pair<AffineExpr, Value>
 categorizeValueByAffineType(MLIRContext *context, Value val, unsigned &numDims,
                             unsigned &numSymbols) {
   AffineExpr d;
   Value resultVal = nullptr;
   if (auto constant = dyn_cast_or_null<ConstantIndexOp>(val.getDefiningOp())) {
     d = getAffineConstantExpr(constant.getValue(), context);
   } else if (isValidSymbol(val) && !isValidDim(val)) {
     d = getAffineSymbolExpr(numSymbols++, context);
     resultVal = val;
   } else {
     d = getAffineDimExpr(numDims++, context);
     resultVal = val;
   }
   return std::make_pair(d, resultVal);
 }
 
-static ValueHandle createBinaryIndexHandle(
-    ValueHandle lhs, ValueHandle rhs,
+static Value createBinaryIndexHandle(
+    Value lhs, Value rhs,
     function_ref<AffineExpr(AffineExpr, AffineExpr)> affCombiner) {
   MLIRContext *context = ScopedContext::getContext();
   unsigned numDims = 0, numSymbols = 0;
   AffineExpr d0, d1;
   Value v0, v1;
   std::tie(d0, v0) =
-      categorizeValueByAffineType(context, lhs.getValue(), numDims, numSymbols);
+      categorizeValueByAffineType(context, lhs, numDims, numSymbols);
   std::tie(d1, v1) =
-      categorizeValueByAffineType(context, rhs.getValue(), numDims, numSymbols);
+      categorizeValueByAffineType(context, rhs, numDims, numSymbols);
   SmallVector<Value, 2> operands;
-  if (v0) {
+  if (v0)
     operands.push_back(v0);
-  }
-  if (v1) {
+  if (v1)
     operands.push_back(v1);
-  }
   auto map = AffineMap::get(numDims, numSymbols, affCombiner(d0, d1));
+
   // TODO: createOrFold when available.
   Operation *op =
       makeComposedAffineApply(ScopedContext::getBuilder(),
                               ScopedContext::getLocation(), map, operands)
           .getOperation();
   assert(op->getNumResults() == 1 && "Expected single result AffineApply");
-  return ValueHandle(op->getResult(0));
+  return op->getResult(0);
 }
 
 template <typename IOp, typename FOp>
-static ValueHandle createBinaryHandle(
-    ValueHandle lhs, ValueHandle rhs,
+static Value createBinaryHandle(
+    Value lhs, Value rhs,
     function_ref<AffineExpr(AffineExpr, AffineExpr)> affCombiner) {
-  auto thisType = lhs.getValue().getType();
-  auto thatType = rhs.getValue().getType();
+  auto thisType = lhs.getType();
+  auto thatType = rhs.getType();
   assert(thisType == thatType && "cannot mix types in operators");
   (void)thisType;
   (void)thatType;
   if (thisType.isIndex()) {
     return createBinaryIndexHandle(lhs, rhs, affCombiner);
   } else if (thisType.isSignlessInteger()) {
-    return createBinaryHandle<IOp>(lhs, rhs);
+    return ValueBuilder<IOp>(lhs, rhs);
   } else if (thisType.isa<FloatType>()) {
-    return createBinaryHandle<FOp>(lhs, rhs);
+    return ValueBuilder<FOp>(lhs, rhs);
   } else if (thisType.isa<VectorType>() || thisType.isa<TensorType>()) {
     auto aggregateType = thisType.cast<ShapedType>();
     if (aggregateType.getElementType().isSignlessInteger())
-      return createBinaryHandle<IOp>(lhs, rhs);
+      return ValueBuilder<IOp>(lhs, rhs);
     else if (aggregateType.getElementType().isa<FloatType>())
-      return createBinaryHandle<FOp>(lhs, rhs);
+      return ValueBuilder<FOp>(lhs, rhs);
   }
-  llvm_unreachable("failed to create a ValueHandle");
+  llvm_unreachable("failed to create a Value");
 }
 
-ValueHandle mlir::edsc::op::operator+(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator+(Value lhs, Value rhs) {
   return createBinaryHandle<AddIOp, AddFOp>(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 + d1; });
 }
 
-ValueHandle mlir::edsc::op::operator-(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator-(Value lhs, Value rhs) {
   return createBinaryHandle<SubIOp, SubFOp>(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 - d1; });
 }
 
-ValueHandle mlir::edsc::op::operator*(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator*(Value lhs, Value rhs) {
   return createBinaryHandle<MulIOp, MulFOp>(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 * d1; });
 }
 
-ValueHandle mlir::edsc::op::operator/(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator/(Value lhs, Value rhs) {
   return createBinaryHandle<SignedDivIOp, DivFOp>(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) -> AffineExpr {
         llvm_unreachable("only exprs of non-index type support operator/");
       });
 }
 
-ValueHandle mlir::edsc::op::operator%(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator%(Value lhs, Value rhs) {
   return createBinaryHandle<SignedRemIOp, RemFOp>(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 % d1; });
 }
 
-ValueHandle mlir::edsc::op::floorDiv(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::floorDiv(Value lhs, Value rhs) {
   return createBinaryIndexHandle(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0.floorDiv(d1); });
 }
 
-ValueHandle mlir::edsc::op::ceilDiv(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::ceilDiv(Value lhs, Value rhs) {
   return createBinaryIndexHandle(
       lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0.ceilDiv(d1); });
 }
 
-ValueHandle mlir::edsc::op::operator!(ValueHandle value) {
-  assert(value.getType().isInteger(1) && "expected boolean expression");
-  return ValueHandle::create<ConstantIntOp>(1, 1) - value;
-}
-
-ValueHandle mlir::edsc::op::operator&&(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator&&(Value lhs, Value rhs) {
   assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
   assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
-  return ValueHandle::create<AndOp>(lhs, rhs);
+  return ValueBuilder<AndOp>(lhs, rhs);
 }
 
-ValueHandle mlir::edsc::op::operator||(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator||(Value lhs, Value rhs) {
   assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
   assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
-  return ValueHandle::create<OrOp>(lhs, rhs);
+  return ValueBuilder<OrOp>(lhs, rhs);
 }
 
-static ValueHandle createIComparisonExpr(CmpIPredicate predicate,
-                                         ValueHandle lhs, ValueHandle rhs) {
+static Value createIComparisonExpr(CmpIPredicate predicate, Value lhs,
+                                   Value rhs) {
   auto lhsType = lhs.getType();
   auto rhsType = rhs.getType();
   (void)lhsType;
   (void)rhsType;
   assert(lhsType == rhsType && "cannot mix types in operators");
   assert((lhsType.isa<IndexType>() || lhsType.isSignlessInteger()) &&
          "only integer comparisons are supported");
 
-  auto op = ScopedContext::getBuilder().create<CmpIOp>(
-      ScopedContext::getLocation(), predicate, lhs.getValue(), rhs.getValue());
-  return ValueHandle(op.getResult());
+  return ScopedContext::getBuilder().create<CmpIOp>(
+      ScopedContext::getLocation(), predicate, lhs, rhs);
 }
 
-static ValueHandle createFComparisonExpr(CmpFPredicate predicate,
-                                         ValueHandle lhs, ValueHandle rhs) {
+static Value createFComparisonExpr(CmpFPredicate predicate, Value lhs,
+                                   Value rhs) {
   auto lhsType = lhs.getType();
   auto rhsType = rhs.getType();
   (void)lhsType;
   (void)rhsType;
   assert(lhsType == rhsType && "cannot mix types in operators");
   assert(lhsType.isa<FloatType>() && "only float comparisons are supported");
 
-  auto op = ScopedContext::getBuilder().create<CmpFOp>(
-      ScopedContext::getLocation(), predicate, lhs.getValue(), rhs.getValue());
-  return ValueHandle(op.getResult());
+  return ScopedContext::getBuilder().create<CmpFOp>(
+      ScopedContext::getLocation(), predicate, lhs, rhs);
 }
 
 // All floating point comparison are ordered through EDSL
-ValueHandle mlir::edsc::op::operator==(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::eq(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::OEQ, lhs, rhs)
              : createIComparisonExpr(CmpIPredicate::eq, lhs, rhs);
 }
-ValueHandle mlir::edsc::op::operator!=(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::ne(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::ONE, lhs, rhs)
              : createIComparisonExpr(CmpIPredicate::ne, lhs, rhs);
 }
-ValueHandle mlir::edsc::op::operator<(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator<(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::OLT, lhs, rhs)
              :
              // TODO(ntv,zinenko): signed by default, how about unsigned?
              createIComparisonExpr(CmpIPredicate::slt, lhs, rhs);
 }
-ValueHandle mlir::edsc::op::operator<=(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator<=(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::OLE, lhs, rhs)
              : createIComparisonExpr(CmpIPredicate::sle, lhs, rhs);
 }
-ValueHandle mlir::edsc::op::operator>(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator>(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::OGT, lhs, rhs)
              : createIComparisonExpr(CmpIPredicate::sgt, lhs, rhs);
 }
-ValueHandle mlir::edsc::op::operator>=(ValueHandle lhs, ValueHandle rhs) {
+Value mlir::edsc::op::operator>=(Value lhs, Value rhs) {
   auto type = lhs.getType();
   return type.isa<FloatType>()
              ? createFComparisonExpr(CmpFPredicate::OGE, lhs, rhs)
              : createIComparisonExpr(CmpIPredicate::sge, lhs, rhs);
 }

mlir/lib/Dialect/GPU/Transforms/MemoryPromotion.cpp

 /// values using the bounds derived from the "from" value. Emits at least
 /// GPUDialect::getNumWorkgroupDimensions() loops, completing the nest with
 /// single-iteration loops. Maps the innermost loops to thread dimensions, in
 /// reverse order to enable access coalescing in the innermost loop.
 static void insertCopyLoops(OpBuilder &builder, Location loc,
                             MemRefBoundsCapture &bounds, Value from, Value to) {
   // Create EDSC handles for bounds.
   unsigned rank = bounds.rank();
-  SmallVector<ValueHandle, 4> lbs, ubs, steps;
+  SmallVector<Value, 4> lbs, ubs, steps;
 
   // Make sure we have enough loops to use all thread dimensions, these trivial
   // loops should be outermost and therefore inserted first.
   if (rank < GPUDialect::getNumWorkgroupDimensions()) {
     unsigned extraLoops = GPUDialect::getNumWorkgroupDimensions() - rank;
-    ValueHandle zero = std_constant_index(0);
-    ValueHandle one = std_constant_index(1);
+    Value zero = std_constant_index(0);
+    Value one = std_constant_index(1);
     lbs.resize(extraLoops, zero);
     ubs.resize(extraLoops, one);
     steps.resize(extraLoops, one);
   }
 
   // Add existing bounds.
   lbs.append(bounds.getLbs().begin(), bounds.getLbs().end());
   ubs.append(bounds.getUbs().begin(), bounds.getUbs().end());
for (unsigned i = 0; i < 3; ++i) {
     auto dimName = builder.getStringAttr(getDimName(i));
     threadIds.push_back(
         builder.create<gpu::ThreadIdOp>(loc, indexType, dimName));
     blockDims.push_back(
         builder.create<gpu::BlockDimOp>(loc, indexType, dimName));
   }
 
   // Produce the loop nest with copies.
-  SmallVector<ValueHandle, 8> ivs(lbs.size(), ValueHandle(indexType));
-  auto ivPtrs = makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
-  LoopNestBuilder(ivPtrs, lbs, ubs, steps)([&]() {
+  SmallVector<Value, 8> ivs(lbs.size());
+  LoopNestBuilder(ivs, lbs, ubs, steps)([&]() {
     auto activeIvs = llvm::makeArrayRef(ivs).take_back(rank);
     StdIndexedValue fromHandle(from), toHandle(to);
     toHandle(activeIvs) = fromHandle(activeIvs);
   });
 
   // Map the innermost loops to threads in reverse order.
   for (auto en :
        llvm::enumerate(llvm::reverse(llvm::makeArrayRef(ivs).take_back(
            GPUDialect::getNumWorkgroupDimensions())))) {
-    auto loop = cast<loop::ForOp>(
-        en.value().getValue().getParentRegion()->getParentOp());
+    Value v = en.value();
+    auto loop = cast<loop::ForOp>(v.getParentRegion()->getParentOp());
     mapLoopToProcessorIds(loop, {threadIds[en.index()]},
                           {blockDims[en.index()]});
   }
 }
 
 /// Emits the loop nests performing the copy to the designated location in the
 /// beginning of the region, and from the designated location immediately before
 /// the terminator of the first block of the region. The region is expected to

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

 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
-mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(ValueHandle *iv,
-                                               ValueHandle range) {
+mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(Value *iv, Value range) {
   assert(range.getType() && "expected !linalg.range type");
-  assert(range.getValue().getDefiningOp() &&
-         "need operations to extract range parts");
-  auto rangeOp = cast<RangeOp>(range.getValue().getDefiningOp());
+  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);
-  *iv = ValueHandle(forOp.getInductionVar());
+  *iv = forOp.getInductionVar();
   auto *body = forOp.getBody();
   enter(body, /*prev=*/1);
 }
 
-mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(ValueHandle *iv,
+mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(Value *iv,
                                                SubViewOp::Range range) {
   auto forOp =
       OperationHandle::createOp<ForOp>(range.offset, range.size, range.stride);
-  *iv = ValueHandle(forOp.getInductionVar());
+  *iv = forOp.getInductionVar();
   auto *body = forOp.getBody();
   enter(body, /*prev=*/1);
 }
 
-ValueHandle
-mlir::edsc::LoopRangeBuilder::operator()(std::function<void(void)> fun) {
+Value mlir::edsc::LoopRangeBuilder::operator()(std::function<void(void)> fun) {
   if (fun)
     fun();
   exit();
-  return ValueHandle::null();
+  return Value();
 }
 
 mlir::edsc::LoopNestRangeBuilder::LoopNestRangeBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<SubViewOp::Range> ranges) {
+    MutableArrayRef<Value> ivs, ArrayRef<SubViewOp::Range> ranges) {
   loops.reserve(ranges.size());
   for (unsigned i = 0, e = ranges.size(); i < e; ++i) {
-    loops.emplace_back(ivs[i], ranges[i]);
+    loops.emplace_back(&ivs[i], ranges[i]);
   }
   assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
 }
 
 mlir::edsc::LoopNestRangeBuilder::LoopNestRangeBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> ranges) {
+    MutableArrayRef<Value> ivs, ArrayRef<Value> ranges) {
   loops.reserve(ranges.size());
   for (unsigned i = 0, e = ranges.size(); i < e; ++i) {
-    loops.emplace_back(ivs[i], ranges[i]);
+    loops.emplace_back(&ivs[i], ranges[i]);
   }
   assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
 }
 
-mlir::edsc::LoopNestRangeBuilder::LoopNestRangeBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<Value> ranges)
-    : LoopNestRangeBuilder(
-          ivs, SmallVector<ValueHandle, 4>(ranges.begin(), ranges.end())) {}
-
-ValueHandle LoopNestRangeBuilder::LoopNestRangeBuilder::operator()(
+Value LoopNestRangeBuilder::LoopNestRangeBuilder::operator()(
     std::function<void(void)> fun) {
   if (fun)
     fun();
   for (auto &lit : reverse(loops)) {
     lit({});
   }
-  return ValueHandle::null();
+  return Value();
 }
 
 namespace mlir {
 namespace edsc {
 
 template <>
 GenericLoopNestRangeBuilder<loop::ForOp>::GenericLoopNestRangeBuilder(
-    ArrayRef<edsc::ValueHandle *> ivs, ArrayRef<Value> ranges) {
+    MutableArrayRef<Value> ivs, ArrayRef<Value> ranges) {
   builder = std::make_unique<LoopNestRangeBuilder>(ivs, ranges);
 }
 
 template <>
 GenericLoopNestRangeBuilder<AffineForOp>::GenericLoopNestRangeBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<Value> ranges) {
-  SmallVector<ValueHandle, 4> lbs;
-  SmallVector<ValueHandle, 4> ubs;
+    MutableArrayRef<Value> ivs, ArrayRef<Value> ranges) {
+  SmallVector<Value, 4> lbs;
+  SmallVector<Value, 4> ubs;
   SmallVector<int64_t, 4> steps;
   for (Value range : ranges) {
     assert(range.getType() && "expected linalg.range type");
     assert(range.getDefiningOp() && "need operations to extract range parts");
     RangeOp rangeOp = cast<RangeOp>(range.getDefiningOp());
     lbs.emplace_back(rangeOp.min());
     ubs.emplace_back(rangeOp.max());
     steps.emplace_back(rangeOp.step());
   }
   builder = std::make_unique<AffineLoopNestBuilder>(ivs, lbs, ubs, steps);
 }
 
 template <>
 GenericLoopNestRangeBuilder<loop::ParallelOp>::GenericLoopNestRangeBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<Value> ranges) {
-  SmallVector<ValueHandle, 4> lbs, ubs, steps;
+    MutableArrayRef<Value> ivs, ArrayRef<Value> ranges) {
+  SmallVector<Value, 4> lbs, ubs, steps;
   for (Value range : ranges) {
     assert(range.getType() && "expected linalg.range type");
     assert(range.getDefiningOp() && "need operations to extract range parts");
     RangeOp rangeOp = cast<RangeOp>(range.getDefiningOp());
     lbs.emplace_back(rangeOp.min());
     ubs.emplace_back(rangeOp.max());
     steps.emplace_back(rangeOp.step());
   }
blockTypes.push_back((it.index() < nViews)
                              ? getElementTypeOrSelf(it.value())
                              : it.value().getType());
 
   assert(op->getNumRegions() == 1);
   assert(op->getRegion(0).empty());
   OpBuilder opBuilder(op);
   ScopedContext scope(opBuilder, op->getLoc());
   BlockHandle b;
-  auto handles = makeValueHandles(blockTypes);
-  BlockBuilder(&b, op->getRegion(0),
-               makeHandlePointers(MutableArrayRef<ValueHandle>(handles)))(
-      [&] { regionBuilder(b.getBlock()->getArguments()); });
+  SmallVector<Value, 8> handles(blockTypes.size());
+  BlockBuilder(&b, op->getRegion(0), blockTypes,
+               handles)([&] { regionBuilder(b.getBlock()->getArguments()); });
   assert(op->getRegion(0).getBlocks().size() == 1);
   return op;
 }
 
 void mlir::edsc::ops::mulRegionBuilder(ArrayRef<BlockArgument> args) {
   using edsc::op::operator+;
   using edsc::op::operator*;
   assert(args.size() == 2 && "expected 2 block arguments");
-  ValueHandle a(args[0]), b(args[1]);
-  linalg_yield((a * b).getValue());
+  Value a(args[0]), b(args[1]);
+  linalg_yield(a * b);
 }
 
 void mlir::edsc::ops::macRegionBuilder(ArrayRef<BlockArgument> args) {
   using edsc::op::operator+;
   using edsc::op::operator*;
   assert(args.size() == 3 && "expected 3 block arguments");
-  ValueHandle a(args[0]), b(args[1]), c(args[2]);
-  linalg_yield((c + a * b).getValue());
+  Value a(args[0]), b(args[1]), c(args[2]);
+  linalg_yield(c + a * b);
 }
 
 Operation *mlir::edsc::ops::linalg_generic_pointwise(
     UnaryPointwiseOpBuilder unaryOp, StructuredIndexed I, StructuredIndexed O) {
   SmallVector<IteratorType, 4> iterTypes(O.getExprs().size(),
                                          IteratorType::Parallel);
   if (O.getType().isa<RankedTensorType>()) {
     auto fun = [&unaryOp](ArrayRef<BlockArgument> args) {
       assert(args.size() == 1 && "expected 1 block arguments");
-      ValueHandle a(args[0]);
+      Value a(args[0]);
       linalg_yield(unaryOp(a));
     };
     return makeGenericLinalgOp(iterTypes, {I}, {O}, fun);
   }
   auto fun = [&unaryOp](ArrayRef<BlockArgument> args) {
     assert(args.size() == 2 && "expected 2 block arguments");
-    ValueHandle a(args[0]);
+    Value a(args[0]);
     linalg_yield(unaryOp(a));
   };
   return makeGenericLinalgOp(iterTypes, {I}, {O}, fun);
 }
 
 Operation *mlir::edsc::ops::linalg_generic_pointwise_tanh(StructuredIndexed I,
                                                           StructuredIndexed O) {
-  UnaryPointwiseOpBuilder unOp(
-      [](ValueHandle a) -> Value { return std_tanh(a); });
+  UnaryPointwiseOpBuilder unOp([](Value a) -> Value { return std_tanh(a); });
   return linalg_generic_pointwise(unOp, I, O);
 }
 
 /// Binary pointwise operation (with broadcast) entry point.
 Operation *mlir::edsc::ops::linalg_generic_pointwise(
     BinaryPointwiseOpBuilder binaryOp, StructuredIndexed I1,
     StructuredIndexed I2, StructuredIndexed O) {
   SmallVector<IteratorType, 4> iterTypes(O.getExprs().size(),
                                          IteratorType::Parallel);
   if (O.getType().isa<RankedTensorType>()) {
     auto fun = [&binaryOp](ArrayRef<BlockArgument> args) {
       assert(args.size() == 2 && "expected 2 block arguments");
-      ValueHandle a(args[0]), b(args[1]);
+      Value a(args[0]), b(args[1]);
       linalg_yield(binaryOp(a, b));
     };
     return makeGenericLinalgOp(iterTypes, {I1, I2}, {O}, fun);
   }
   auto fun = [&binaryOp](ArrayRef<BlockArgument> args) {
     assert(args.size() == 3 && "expected 3 block arguments");
-    ValueHandle a(args[0]), b(args[1]);
+    Value a(args[0]), b(args[1]);
     linalg_yield(binaryOp(a, b));
   };
   return makeGenericLinalgOp(iterTypes, {I1, I2}, {O}, fun);
 }
 
 Operation *mlir::edsc::ops::linalg_generic_pointwise_add(StructuredIndexed I1,
                                                          StructuredIndexed I2,
                                                          StructuredIndexed O) {
   using edsc::op::operator+;
   BinaryPointwiseOpBuilder binOp(
-      [](ValueHandle a, ValueHandle b) -> Value { return a + b; });
+      [](Value a, Value b) -> Value { return a + b; });
   return linalg_generic_pointwise(binOp, I1, I2, O);
 }
 
 Operation *mlir::edsc::ops::linalg_generic_pointwise_max(StructuredIndexed I1,
                                                          StructuredIndexed I2,
                                                          StructuredIndexed O) {
-  BinaryPointwiseOpBuilder binOp([](ValueHandle a, ValueHandle b) -> Value {
+  BinaryPointwiseOpBuilder binOp([](Value a, Value b) -> Value {
     using edsc::op::operator>;
-    return std_select(a > b, a, b).getValue();
+    return std_select(a > b, a, b);
   });
   return linalg_generic_pointwise(binOp, I1, I2, O);
 }
 
 Operation *
-mlir::edsc::ops::linalg_generic_matmul(ValueHandle vA, ValueHandle vB,
-                                       ValueHandle vC,
+mlir::edsc::ops::linalg_generic_matmul(Value vA, Value vB, Value vC,
                                        MatmulRegionBuilder regionBuilder) {
   // clang-format off
   AffineExpr m, n, k;
   bindDims(ScopedContext::getContext(), m, n, k);
   StructuredIndexed A(vA), B(vB), C(vC);
   return makeGenericLinalgOp(
     {IteratorType::Parallel, IteratorType::Parallel, IteratorType::Reduction},
     {A({m, k}), B({k, n})},
     {C({m, n})},
     regionBuilder);
   // clang-format on
 }
 
 Operation *
-mlir::edsc::ops::linalg_generic_matmul(ValueHandle vA, ValueHandle vB,
-                                       RankedTensorType tC,
+mlir::edsc::ops::linalg_generic_matmul(Value vA, Value vB, RankedTensorType tC,
                                        MatmulRegionBuilder regionBuilder) {
   // clang-format off
   AffineExpr m, n, k;
   bindDims(ScopedContext::getContext(), m, n, k);
   StructuredIndexed A(vA), B(vB), C(tC);
   return makeGenericLinalgOp(
     {IteratorType::Parallel, IteratorType::Parallel, IteratorType::Reduction},
     {A({m, k}), B({k, n})},
     {C({m, n})},
     regionBuilder);
   // clang-format on
 }
 
 Operation *
-mlir::edsc::ops::linalg_generic_matmul(ValueHandle vA, ValueHandle vB,
-                                       ValueHandle vC, RankedTensorType tD,
+mlir::edsc::ops::linalg_generic_matmul(Value vA, Value vB, Value vC,
+                                       RankedTensorType tD,
                                        MatmulRegionBuilder regionBuilder) {
   // clang-format off
   AffineExpr m, n, k;
   bindDims(ScopedContext::getContext(), m, n, k);
   StructuredIndexed A(vA), B(vB), C(vC), D(tD);
   return makeGenericLinalgOp(
     {IteratorType::Parallel, IteratorType::Parallel, IteratorType::Reduction},
     {A({m, k}), B({k, n}), C({m, n})},
     {D({m, n})},
     regionBuilder);
   // clang-format on
 }
 
-Operation *mlir::edsc::ops::linalg_generic_conv_nhwc(ValueHandle vI,
-                                                     ValueHandle vW,
-                                                     ValueHandle vO,
+Operation *mlir::edsc::ops::linalg_generic_conv_nhwc(Value vI, Value vW,
+                                                     Value vO,
                                                      ArrayRef<int> strides,
                                                      ArrayRef<int> dilations) {
   MLIRContext *ctx = ScopedContext::getContext();
   // TODO(ntv) some template magic to make everything rank-polymorphic.
   assert((dilations.empty() || dilations.size() == 2) && "only 2-D conv atm");
   assert((strides.empty() || strides.size() == 2) && "only 2-D conv atm");
 
   // Some short names.
return makeGenericLinalgOp(
          c}),
       W({kh, kw, c, f})}, {
       O({b, h, w, f})},
     macRegionBuilder);
   // clang-format on
 }
 
 Operation *mlir::edsc::ops::linalg_generic_dilated_conv_nhwc(
-    ValueHandle vI, ValueHandle vW, ValueHandle vO, int depth_multiplier,
-    ArrayRef<int> strides, ArrayRef<int> dilations) {
+    Value vI, Value vW, Value vO, int depth_multiplier, ArrayRef<int> strides,
+    ArrayRef<int> dilations) {
   MLIRContext *ctx = ScopedContext::getContext();
   // TODO(ntv) some template magic to make everything rank-polymorphic.
   assert((dilations.empty() || dilations.size() == 2) && "only 2-D conv atm");
   assert((strides.empty() || strides.size() == 2) && "only 2-D conv atm");
 
   // Some short names.
   auto par = IteratorType::Parallel;
   auto red = IteratorType::Reduction;

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

 
 #define DEBUG_TYPE "linalg-fusion"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
-using folded_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
+using folded_std_constant_index = FoldedValueBuilder<ConstantIndexOp>;
 
 using llvm::dbgs;
 
 /// Implements a simple high-level fusion pass of linalg library operations.
 ///
 /// In each block, linalg ops are processed in reverse textual order.
 /// Given a linalg op `O`, fusion occurs by:
 ///   1. inspecting the linalg ops that write into the views read by `O`. This

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

 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
 using edsc::op::operator+;
-using edsc::op::operator==;
-using mlir::edsc::intrinsics::detail::ValueHandleArray;
 
-static SmallVector<ValueHandle, 8>
-makeCanonicalAffineApplies(OpBuilder &b, Location loc, AffineMap map,
+static SmallVector<Value, 8> makeCanonicalAffineApplies(OpBuilder &b,
+                                                        Location loc,
+                                                        AffineMap map,
                                                         ArrayRef<Value> vals) {
   if (map.isEmpty())
     return {};
   assert(map.getNumSymbols() == 0);
   assert(map.getNumInputs() == vals.size());
-  SmallVector<ValueHandle, 8> res;
+  SmallVector<Value, 8> res;
   res.reserve(map.getNumResults());
   auto dims = map.getNumDims();
   for (auto e : map.getResults()) {
     auto exprMap = AffineMap::get(dims, 0, e);
     SmallVector<Value, 4> operands(vals.begin(), vals.end());
     canonicalizeMapAndOperands(&exprMap, &operands);
     res.push_back(affine_apply(exprMap, operands));
   }
SmallVector<Value, 4> emitLoopRanges(OpBuilder &b, Location loc, AffineMap map,
   for (unsigned idx = 0, e = map.getNumResults(); idx < e; ++idx) {
     res.push_back(
         linalg_range(std_constant_index(0), sizes[idx], std_constant_index(1)));
   }
   return res;
 }
 
 template <typename OpType>
-static void inlineRegionAndEmitStdStore(OpType op,
-                                        ArrayRef<Value> indexedValues,
-                                        ArrayRef<ValueHandleArray> indexing,
-                                        ArrayRef<Value> outputBuffers) {
+static void
+inlineRegionAndEmitStdStore(OpType op, ArrayRef<Value> indexedValues,
+                            ArrayRef<SmallVector<Value, 8>> indexing,
   auto &b = ScopedContext::getBuilder();
   auto &block = op.region().front();
   BlockAndValueMapping map;
   map.map(block.getArguments(), indexedValues);
   for (auto &op : block.without_terminator()) {
     assert(op.getNumRegions() == 0 && "expected a non-nested region");
     auto *newOp = b.clone(op, map);
     map.map(op.getResults(), newOp->getResults());
   }
 
   Operation &terminator = block.back();
   assert(isa<YieldOp>(terminator) &&
          "expected an yield op in the end of the region");
   for (unsigned i = 0, e = terminator.getNumOperands(); i < e; ++i) {
     std_store(map.lookupOrDefault(terminator.getOperand(i)), outputBuffers[i],
-              indexing[i]);
+              ArrayRef<Value>{indexing[i].begin(), indexing[i].end()});
   }
 }
 
 // Returns a pair that contains input indices and output indices of a
 // SingleInputPoolingOp `op`.
+struct InputAndOutputIndices {
+  SmallVector<Value, 8> inputs;
+  SmallVector<Value, 8> outputs;
+};
 template <typename SingleInputPoolingOp>
-static std::pair<SmallVector<ValueHandle, 8>, SmallVector<ValueHandle, 8>>
-getInputAndOutputIndices(ArrayRef<Value> allIvs, SingleInputPoolingOp op) {
+static InputAndOutputIndices getInputAndOutputIndices(ArrayRef<Value> allIvs,
+                                                      SingleInputPoolingOp op) {
   auto &b = ScopedContext::getBuilder();
   auto loc = ScopedContext::getLocation();
   auto mapsRange = op.indexing_maps().template getAsRange<AffineMapAttr>();
   auto maps = llvm::to_vector<8>(
       llvm::map_range(mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
-  SmallVector<ValueHandle, 8> iIdx(
-      makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
-  SmallVector<ValueHandle, 8> oIdx(
-      makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
-  return {iIdx, oIdx};
+  return InputAndOutputIndices{
+      makeCanonicalAffineApplies(b, loc, maps[0], allIvs),
+      makeCanonicalAffineApplies(b, loc, maps[2], allIvs)};
 }
 
 namespace {
 template <typename IndexedValueType, typename LinalgOpType>
 class LinalgScopedEmitter {};
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, CopyOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs, CopyOp copyOp) {
     assert(copyOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto nPar = copyOp.getNumParallelLoops();
     assert(nPar == allIvs.size());
     auto inputIvs =
         permuteIvs(allIvs.take_front(nPar), copyOp.inputPermutation());
     auto outputIvs =
         permuteIvs(allIvs.take_front(nPar), copyOp.outputPermutation());
-    SmallVector<ValueHandle, 8> iivs(inputIvs.begin(), inputIvs.end());
-    SmallVector<ValueHandle, 8> oivs(outputIvs.begin(), outputIvs.end());
+    SmallVector<Value, 8> iivs(inputIvs.begin(), inputIvs.end());
+    SmallVector<Value, 8> oivs(outputIvs.begin(), outputIvs.end());
     IndexedValueType O(copyOp.getOutputBuffer(0)), I(copyOp.getInput(0));
     // Emit the proper scalar assignment, whether we are dealing with a 0-D or
     // an n-D loop nest; with or without permutations.
     // clang-format off
     nPar > 0 ? O(oivs) = I(iivs) :
                O() = I();
     // clang-format on
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, FillOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs, FillOp fillOp) {
     assert(fillOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto nPar = fillOp.getNumParallelLoops();
     assert(nPar == allIvs.size());
-    auto ivs =
-        SmallVector<ValueHandle, 4>(allIvs.begin(), allIvs.begin() + nPar);
+    auto ivs = SmallVector<Value, 4>(allIvs.begin(), allIvs.begin() + nPar);
     IndexedValueType O(fillOp.getOutputBuffer(0));
     // Emit the proper scalar assignment, whether we are dealing with a 0-D or
     // an n-D loop nest; with or without permutations.
-    nPar > 0 ? O(ivs) = ValueHandle(fillOp.value())
-             : O() = ValueHandle(fillOp.value());
+    nPar > 0 ? O(ivs) = fillOp.value() : O() = fillOp.value();
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, DotOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs, DotOp dotOp) {
     assert(dotOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     assert(allIvs.size() == 1);
-    ValueHandle r_i(allIvs[0]);
+    Value r_i(allIvs[0]);
     IndexedValueType A(dotOp.getInput(0)), B(dotOp.getInput(1)),
         C(dotOp.getOutputBuffer(0));
     // Emit scalar form.
     C() = C() + A(r_i) * B(r_i);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, MatvecOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        MatvecOp matvecOp) {
     assert(matvecOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     assert(allIvs.size() == 2);
-    ValueHandle i(allIvs[0]), r_j(allIvs[1]);
+    Value i(allIvs[0]), r_j(allIvs[1]);
     IndexedValueType A(matvecOp.getInput(0)), B(matvecOp.getInput(1)),
         C(matvecOp.getOutputBuffer(0));
     // Emit scalar form.
     C(i) = C(i) + A(i, r_j) * B(r_j);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, MatmulOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        MatmulOp matmulOp) {
     assert(matmulOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     assert(allIvs.size() == 3);
-    ValueHandle i(allIvs[0]), j(allIvs[1]), r_k(allIvs[2]);
+    Value i(allIvs[0]), j(allIvs[1]), r_k(allIvs[2]);
     IndexedValueType A(matmulOp.getInput(0)), B(matmulOp.getInput(1)),
         C(matmulOp.getOutputBuffer(0));
     // Emit scalar form.
     C(i, j) = C(i, j) + A(i, r_k) * B(r_k, j);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, ConvOp> {
 public:
   /// Returns the input value of convOp. If the indices in `imIdx` is out of
   /// boundary, returns 0 instead.
-  static ValueHandle getConvOpInput(ConvOp convOp, IndexedValueType im,
-                                    ArrayRef<ValueHandle> imIdx) {
+  static Value getConvOpInput(ConvOp convOp, IndexedValueType im,
+                              MutableArrayRef<Value> imIdx) {
     // TODO(ntv): add a level of indirection to linalg.generic.
     if (!convOp.padding())
       return im(imIdx);
 
     auto *context = ScopedContext::getContext();
-    ValueHandle zeroIndex = std_constant_index(0);
-    SmallVector<ValueHandle, 8> conds;
-    SmallVector<ValueHandle, 8> clampedImIdx;
+    Value zeroIndex = std_constant_index(0);
+    SmallVector<Value, 8> conds;
+    SmallVector<Value, 8> clampedImIdx;
     for (auto iter : llvm::enumerate(imIdx)) {
       int idx = iter.index();
       auto dim = iter.value();
       // Only need to iterate over the window dimensions.
       if (idx == 0 || idx == static_cast<int>(imIdx.size()) - 1) {
         clampedImIdx.push_back(dim);
         continue;
       }
 
       using edsc::op::operator<;
       using edsc::op::operator>=;
       using edsc::op::operator||;
-      ValueHandle leftOutOfBound = dim < zeroIndex;
+      Value leftOutOfBound = dim < zeroIndex;
       if (conds.empty())
         conds.push_back(leftOutOfBound);
       else
         conds.push_back(conds.back() || leftOutOfBound);
-      ValueHandle rightBound = std_dim(convOp.input(), idx);
+      Value rightBound = std_dim(convOp.input(), idx);
       conds.push_back(conds.back() || (dim >= rightBound));
 
       // When padding is involved, the indices will only be shifted to negative,
       // so having a max op is enough.
       auto maxMap = AffineMap::get(/*dimCount=*/1, 0,
                                    {getAffineDimExpr(/*position=*/0, context),
                                     getAffineConstantExpr(0, context)},
                                    context);
       clampedImIdx.push_back(
           affine_max(dim.getType(), maxMap, ValueRange{dim}));
     }
 
     auto b = ScopedContext::getBuilder();
     Type type = convOp.input().getType().cast<MemRefType>().getElementType();
-    ValueHandle zero = std_constant(type, b.getZeroAttr(type));
-    ValueHandle readInput = im(clampedImIdx);
+    Value zero = std_constant(type, b.getZeroAttr(type));
+    Value readInput = im(clampedImIdx);
     return conds.empty() ? readInput
-                         : std_select(conds.back(), zero, readInput);
+                         : (Value)std_select(conds.back(), zero, readInput);
   }
 
   static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {
     assert(convOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
     auto mapsRange = convOp.indexing_maps().getAsRange<AffineMapAttr>();
     auto maps = llvm::to_vector<8>(llvm::map_range(
         mapsRange, [](AffineMapAttr a) { return a.getValue(); }));
-    SmallVector<ValueHandle, 8> fIdx(
+    SmallVector<Value, 8> fIdx(
         makeCanonicalAffineApplies(b, loc, maps[0], allIvs));
-    SmallVector<ValueHandle, 8> imIdx(
+    SmallVector<Value, 8> imIdx(
         makeCanonicalAffineApplies(b, loc, maps[1], allIvs));
-    SmallVector<ValueHandle, 8> oIdx(
+    SmallVector<Value, 8> oIdx(
         makeCanonicalAffineApplies(b, loc, maps[2], allIvs));
     IndexedValueType F(convOp.filter()), I(convOp.input()), O(convOp.output());
 
     // Emit scalar form.
-    ValueHandle paddedInput = getConvOpInput(convOp, I, imIdx);
+    Value paddedInput = getConvOpInput(convOp, I, imIdx);
     O(oIdx) += F(fIdx) * paddedInput;
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, PoolingMaxOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        PoolingMaxOp op) {
     auto indices = getInputAndOutputIndices(allIvs, op);
-    ValueHandleArray iIdx(indices.first);
-    ValueHandleArray oIdx(indices.second);
-
     // Emit scalar form.
-    ValueHandle lhs = std_load(op.output(), oIdx);
-    ValueHandle rhs = std_load(op.input(), iIdx);
+    Value lhs = std_load(op.output(), indices.outputs);
+    Value rhs = std_load(op.input(), indices.inputs);
     using edsc::op::operator>;
-    ValueHandle maxValue = std_select(lhs > rhs, lhs, rhs);
-    std_store(maxValue, op.output(), oIdx);
+    Value maxValue = std_select(lhs > rhs, lhs, rhs);
+    std_store(maxValue, op.output(), indices.outputs);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, PoolingMinOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        PoolingMinOp op) {
     auto indices = getInputAndOutputIndices(allIvs, op);
-    ValueHandleArray iIdx(indices.first);
-    ValueHandleArray oIdx(indices.second);
-
     // Emit scalar form.
-    ValueHandle lhs = std_load(op.output(), oIdx);
-    ValueHandle rhs = std_load(op.input(), iIdx);
+    Value lhs = std_load(op.output(), indices.outputs);
+    Value rhs = std_load(op.input(), indices.inputs);
     using edsc::op::operator<;
-    ValueHandle minValue = std_select(lhs < rhs, lhs, rhs);
-    std_store(minValue, op.output(), oIdx);
+    Value minValue = std_select(lhs < rhs, lhs, rhs);
+    std_store(minValue, op.output(), indices.outputs);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, PoolingSumOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        PoolingSumOp op) {
     auto indices = getInputAndOutputIndices(allIvs, op);
-    SmallVector<ValueHandle, 8> iIdx = indices.first;
-    SmallVector<ValueHandle, 8> oIdx = indices.second;
     IndexedValueType input(op.input()), output(op.output());
 
     // Emit scalar form.
-    output(oIdx) += input(iIdx);
+    output(indices.outputs) += input(indices.inputs);
   }
 };
 
 // Emits the MLIR for the scalar part of the generic op by:
 //   1. Emitting std_load and std_store ops for each input and output
 //      view in order. This is achieved by applying the appropriate input or
 //      output map to the enclosing induction variables.
 //   2. Emitting a call to `op.fun()` that takes as arguments the scalars

 class LinalgScopedEmitter<IndexedValueType, GenericOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        GenericOp genericOp) {
     assert(genericOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
-    using edsc::intrinsics::detail::ValueHandleArray;
     unsigned nInputs = genericOp.getNumInputs();
     unsigned nOutputs = genericOp.getNumOutputs();
     SmallVector<Value, 4> indexedValues(nInputs + nOutputs);
 
     // 1.a. Emit std_load from input views.
     for (unsigned i = 0; i < nInputs; ++i) {
-      ValueHandleArray indexing(makeCanonicalAffineApplies(
-          b, loc, genericOp.getInputIndexingMap(i), allIvs));
+      auto indexing = makeCanonicalAffineApplies(
+          b, loc, genericOp.getInputIndexingMap(i), allIvs);
       indexedValues[i] = std_load(genericOp.getInput(i), indexing);
     }
 
     // 1.b. Emit std_load from output views.
     // TODO(mravishankar): Avoid the loads if the corresponding argument of the
     // region has no uses.
     for (unsigned i = 0; i < nOutputs; ++i) {
       Value output = genericOp.getOutputBuffer(i);
-      ValueHandleArray indexing(makeCanonicalAffineApplies(
-          b, loc, genericOp.getOutputIndexingMap(i), allIvs));
+      auto indexing = makeCanonicalAffineApplies(
+          b, loc, genericOp.getOutputIndexingMap(i), allIvs);
       indexedValues[nInputs + i] = std_load(output, indexing);
     }
 
     // TODO(ntv): When a region inliner exists, use it.
     // 2. Inline region, currently only works for a single basic block.
     // 3. Emit std_store.
-    SmallVector<ValueHandleArray, 8> indexing;
+    SmallVector<SmallVector<Value, 8>, 8> indexing;
     SmallVector<Value, 8> outputBuffers;
     for (unsigned i = 0; i < nOutputs; ++i) {
-      indexing.emplace_back(makeCanonicalAffineApplies(
+      indexing.push_back(makeCanonicalAffineApplies(
           b, loc, genericOp.getOutputIndexingMap(i), allIvs));
       outputBuffers.push_back(genericOp.getOutputBuffer(i));
     }
     inlineRegionAndEmitStdStore(genericOp, indexedValues, indexing,
                                 outputBuffers);
   }
 };
 

 class LinalgScopedEmitter<IndexedValueType, IndexedGenericOp> {
 public:
   static void emitScalarImplementation(ArrayRef<Value> allIvs,
                                        IndexedGenericOp indexedGenericOp) {
     assert(indexedGenericOp.hasBufferSemantics() &&
            "expected linalg op with buffer semantics");
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
-    using edsc::intrinsics::detail::ValueHandleArray;
     unsigned nInputs = indexedGenericOp.getNumInputs();
     unsigned nOutputs = indexedGenericOp.getNumOutputs();
     unsigned nLoops = allIvs.size();
     SmallVector<Value, 4> indexedValues(nLoops + nInputs + nOutputs);
 
     for (unsigned i = 0; i < nLoops; ++i) {
       indexedValues[i] = allIvs[i];
     }
 
     // 1.a. Emit std_load from input views.
     for (unsigned i = 0; i < nInputs; ++i) {
       Value input = indexedGenericOp.getInput(i);
-      ValueHandleArray indexing(makeCanonicalAffineApplies(
-          b, loc, indexedGenericOp.getInputIndexingMap(i), allIvs));
+      auto indexing = makeCanonicalAffineApplies(
+          b, loc, indexedGenericOp.getInputIndexingMap(i), allIvs);
       indexedValues[nLoops + i] = std_load(input, indexing);
     }
 
     // 1.b. Emit std_load from output views.
     for (unsigned i = 0; i < nOutputs; ++i) {
       Value output = indexedGenericOp.getOutputBuffer(i);
-      ValueHandleArray indexing(makeCanonicalAffineApplies(
-          b, loc, indexedGenericOp.getOutputIndexingMap(i), allIvs));
+      auto indexing = makeCanonicalAffineApplies(
+          b, loc, indexedGenericOp.getOutputIndexingMap(i), allIvs);
       indexedValues[nLoops + nInputs + i] = std_load(output, indexing);
     }
 
     // TODO(ntv): When a region inliner exists, use it.
     // 2. Inline region, currently only works for a single basic block.
     // 3. Emit std_store.
-    SmallVector<ValueHandleArray, 8> indexing;
+    SmallVector<SmallVector<Value, 8>, 8> indexing;
     SmallVector<Value, 8> outputBuffers;
     for (unsigned i = 0; i < nOutputs; ++i) {
-      indexing.emplace_back(makeCanonicalAffineApplies(
+      indexing.push_back(makeCanonicalAffineApplies(
           b, loc, indexedGenericOp.getOutputIndexingMap(i), allIvs));
       outputBuffers.push_back(indexedGenericOp.getOutputBuffer(i));
     }
     inlineRegionAndEmitStdStore(indexedGenericOp, indexedValues, indexing,
                                 outputBuffers);
   }
 };
 

 /// to be able to partially specialize this for different LoopTy.
 template <typename LoopTy, typename ConcreteOpTy>
 class GenerateLoopNest {
 public:
   using IndexedValueTy =
       typename std::conditional<std::is_same<LoopTy, AffineForOp>::value,
                                 AffineIndexedValue, StdIndexedValue>::type;
   static void doit(ConcreteOpTy linalgOp, ArrayRef<Value> loopRanges,
-                   MutableArrayRef<ValueHandle> allIvs) {
-    SmallVector<ValueHandle *, 4> allPIvs =
-        makeHandlePointers(MutableArrayRef<ValueHandle>(allIvs));
-
-    GenericLoopNestRangeBuilder<LoopTy>(allPIvs, loopRanges)([&] {
+                   MutableArrayRef<Value> allIvs) {
+    GenericLoopNestRangeBuilder<LoopTy>(allIvs, loopRanges)([&] {
       SmallVector<Value, 4> allIvValues(allIvs.begin(), allIvs.end());
       LinalgScopedEmitter<IndexedValueTy,
                           ConcreteOpTy>::emitScalarImplementation(allIvValues,
                                                                   linalgOp);
     });
   }
 };
 
 /// Generates loops nest using loop.parallel. loop.parallel is only used for the
 /// outer parallel loops. All other loops are generated using loop.for
 /// operation.
 template <typename ConcreteOpTy>
 class GenerateLoopNest<loop::ParallelOp, ConcreteOpTy> {
 public:
   using IndexedValueTy = StdIndexedValue;
 
   static void doit(ConcreteOpTy linalgOp, ArrayRef<Value> loopRanges,
-                   MutableArrayRef<ValueHandle> allIvs) {
+                   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<ValueHandle *, 4> allPIvs =
-        makeHandlePointers(MutableArrayRef<ValueHandle>(allIvs));
-
     SmallVector<OperationHandle, 4> allLoops(nLoopOps, OperationHandle());
     SmallVector<OperationHandle *, 4> allPLoops;
     allPLoops.reserve(allLoops.size());
     for (OperationHandle &loop : allLoops)
       allPLoops.push_back(&loop);
-
-    ArrayRef<ValueHandle *> allPIvsRef(allPIvs);
     ArrayRef<OperationHandle *> allPLoopsRef(allPLoops);
 
     if (nOuterPar) {
       GenericLoopNestRangeBuilder<loop::ParallelOp>(
-          allPIvsRef.take_front(nOuterPar),
-          loopRanges.take_front(nOuterPar))([&] {
+          allIvs.take_front(nOuterPar), loopRanges.take_front(nOuterPar))([&] {
         GenericLoopNestRangeBuilder<loop::ForOp>(
-            allPIvsRef.drop_front(nOuterPar),
+            allIvs.drop_front(nOuterPar),
             loopRanges.drop_front(nOuterPar))([&] {
           SmallVector<Value, 4> allIvValues(allIvs.begin(), allIvs.end());
           LinalgScopedEmitter<StdIndexedValue, ConcreteOpTy>::
               emitScalarImplementation(allIvValues, linalgOp);
         });
       });
     } else {
       // If there are no parallel loops then fallback to generating all loop.for
       // operations.
-      GenericLoopNestRangeBuilder<loop::ForOp>(allPIvsRef, loopRanges)([&] {
+      GenericLoopNestRangeBuilder<loop::ForOp>(allIvs, loopRanges)([&] {
         SmallVector<Value, 4> allIvValues(allIvs.begin(), allIvs.end());
         LinalgScopedEmitter<StdIndexedValue,
                             ConcreteOpTy>::emitScalarImplementation(allIvValues,
                                                                     linalgOp);
       });
     }
   }
 };
LinalgOpToLoopsImpl<LoopTy, ConcreteOpTy>::doit(Operation *op,
   if (!invertedMap)
     return {};
   if (invertedMap.isEmpty()) {
     LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(
         {}, linalgOp);
     return LinalgLoops();
   }
 
-  SmallVector<ValueHandle, 4> allIvs(nLoops,
-                                     ValueHandle(rewriter.getIndexType()));
+  SmallVector<Value, 4> allIvs(nLoops);
   auto loopRanges =
       emitLoopRanges(scope.getBuilder(), scope.getLocation(), invertedMap,
                      getViewSizes(rewriter, linalgOp));
   assert(loopRanges.size() == allIvs.size());
   Impl::doit(linalgOp, loopRanges, allIvs);
   // Number of loop ops might be different from the number of ivs since some
   // loops like affine.parallel and loop.parallel have multiple ivs.
   llvm::SetVector<Operation *> loopSet;
-  for (ValueHandle &iv : allIvs) {
-    if (!iv.hasValue())
+  for (Value iv : allIvs) {
+    if (!iv)
       return {};
     // The induction variable is a block argument of the entry block of the
     // loop operation.
-    BlockArgument ivVal = iv.getValue().dyn_cast<BlockArgument>();
+    BlockArgument ivVal = iv.dyn_cast<BlockArgument>();
     if (!ivVal)
       return {};
     loopSet.insert(ivVal.getOwner()->getParentOp());
   }
   LinalgLoops loops(loopSet.begin(), loopSet.end());
   return loops;
 }
 

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

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/LinalgTransforms.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
+#include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
LogicalResult mlir::linalg::vectorizeLinalgOpPrecondition(Operation *op) {
   if (!llvm::all_of(genericOp.getInputsAndOutputBuffers(),
                     isStaticMemRefWithIdentityLayout))
     return failure();
   return success();
 }
 
 SmallVector<Value, 0> mlir::linalg::vectorizeLinalgOp(PatternRewriter &rewriter,
                                                       Operation *op) {
-  using vector_contract = edsc::intrinsics::ValueBuilder<vector::ContractionOp>;
-  using vector_broadcast = edsc::intrinsics::ValueBuilder<vector::BroadcastOp>;
-  using vector_type_cast = edsc::intrinsics::ValueBuilder<vector::TypeCastOp>;
-
   assert(succeeded(vectorizeLinalgOpPrecondition(op)) &&
          "DRR failure case must be a precondition");
   auto linalgOp = cast<linalg::LinalgOp>(op);
   assert(linalgOp.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   if (auto convOp = dyn_cast<linalg::ConvOp>(op)) {
     // TODO(ntv): add a level of indirection to linalg.generic.
     if (convOp.padding())
       llvm_unreachable("Unexpected conv with padding");
   }
 
   edsc::ScopedContext scope(rewriter, op->getLoc());
 
   if (auto fillOp = dyn_cast<linalg::FillOp>(op)) {
     // Vectorize fill as a vector.broadcast.
     LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE
                          "]: Rewrite linalg.fill as vector.broadcast: "
                       << *op << ":\n");
     auto dstMemrefVec = vector_type_cast(fillOp.getOutputBuffer(0));
-    auto dstVec = std_load(dstMemrefVec);
-    auto resVec = vector_broadcast(dstVec, fillOp.value());
+    Value dstVec = std_load(dstMemrefVec);
+    auto resVec = vector_broadcast(dstVec.getType(), fillOp.value());
     std_store(resVec, dstMemrefVec);
   } else {
     // Vectorize other ops as vector contraction (currently only matmul).
     LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE
                          "]: Rewrite linalg op as vector.contract: "
                       << *op << ":\n");
     auto vA = std_load(vector_type_cast(linalgOp.getInput(0)));
     auto vB = std_load(vector_type_cast(linalgOp.getInput(1)));

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

 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
 using llvm::SetVector;
 
-using folded_affine_min = folded::ValueBuilder<AffineMinOp>;
-using folded_linalg_range = folded::ValueBuilder<linalg::RangeOp>;
-using folded_std_dim = folded::ValueBuilder<DimOp>;
-using folded_std_subview = folded::ValueBuilder<SubViewOp>;
-using folded_std_view = folded::ValueBuilder<ViewOp>;
+using folded_affine_min = FoldedValueBuilder<AffineMinOp>;
+using folded_linalg_range = FoldedValueBuilder<linalg::RangeOp>;
+using folded_std_dim = FoldedValueBuilder<DimOp>;
+using folded_std_subview = FoldedValueBuilder<SubViewOp>;
+using folded_std_view = FoldedValueBuilder<ViewOp>;
 
 #define DEBUG_TYPE "linalg-promotion"
 
 /// If `size` comes from an AffineMinOp and one of the dimensions of AffineMin
 /// is a constant then return a new value set to the smallest such constant.
 /// Otherwise return size.
 static Value extractSmallestConstantBoundingSize(OpBuilder &b, Location loc,
                                                  Value size) {
static PromotionInfo promoteFullTileBuffer(OpBuilder &b, Location loc,
   SmallVector<Value, 8> fullSizes, partialSizes;
   fullSizes.reserve(rank);
   partialSizes.reserve(rank);
   for (auto en : llvm::enumerate(subView.getRanges())) {
     auto rank = en.index();
     auto rangeValue = en.value();
     // Try to extract a tight constant
     Value size = extractSmallestConstantBoundingSize(b, loc, rangeValue.size);
-    allocSize = folded_std_muli(folder, allocSize, size).getValue();
+    allocSize = folded_std_muli(folder, allocSize, size);
     fullSizes.push_back(size);
     partialSizes.push_back(folded_std_dim(folder, subView, rank));
   }
   SmallVector<int64_t, 4> dynSizes(fullSizes.size(), -1);
   auto buffer =
       allocBuffer(viewType.getElementType(), allocSize, dynamicBuffers, folder);
   auto fullLocalView = folded_std_view(
       folder, MemRefType::get(dynSizes, viewType.getElementType()), buffer,

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

 #include "llvm/Support/CommandLine.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
-using folded_affine_min = folded::ValueBuilder<AffineMinOp>;
+using folded_affine_min = FoldedValueBuilder<AffineMinOp>;
 
 #define DEBUG_TYPE "linalg-tiling"
 
 static bool isZero(Value v) {
   return isa_and_nonnull<ConstantIndexOp>(v.getDefiningOp()) &&
          cast<ConstantIndexOp>(v.getDefiningOp()).getValue() == 0;
 }
 

 //       <some operations that use %transformed_i, %transformed_j>
 //     }: memref<?x?xf32, #strided>, memref<?x?xf32, #strided>
 //   }
 // }
 //
 // TODO(pifon, ntv): Investigate whether mixing implicit and explicit indices
 // does not lead to losing information.
 static void transformIndexedGenericOpIndices(
-    OpBuilder &b, LinalgOp op, ArrayRef<ValueHandle *> pivs,
+    OpBuilder &b, LinalgOp op, SmallVectorImpl<Value> &ivs,
     const LoopIndexToRangeIndexMap &loopIndexToRangeIndex) {
   assert(op.hasBufferSemantics() && "expected linalg op with buffer semantics");
   auto indexedGenericOp = dyn_cast<IndexedGenericOp>(op.getOperation());
   if (!indexedGenericOp)
     return;
 
   // `linalg.indexed_generic` comes in two flavours. One has a region with a
   // single block that defines the loop body. The other has a `fun` attribute
static void transformIndexedGenericOpIndices(
   for (unsigned i = 0; i < indexedGenericOp.getNumLoops(); ++i) {
     auto rangeIndex = loopIndexToRangeIndex.find(i);
     if (rangeIndex == loopIndexToRangeIndex.end())
       continue;
     Value oldIndex = block.getArgument(i);
     // Offset the index argument `i` by the value of the corresponding induction
     // variable and replace all uses of the previous value.
     Value newIndex = b.create<AddIOp>(indexedGenericOp.getLoc(), oldIndex,
-                                      pivs[rangeIndex->second]->getValue());
+                                      ivs[rangeIndex->second]);
     for (auto &use : oldIndex.getUses()) {
       if (use.getOwner() == newIndex.getDefiningOp())
         continue;
       use.set(newIndex);
     }
   }
 }
 
Optional<TiledLinalgOp> static tileLinalgOpImpl(OpBuilder &b, LinalgOp op,
   std::tie(loopRanges, loopIndexToRangeIndex) =
       makeTiledLoopRanges(b, scope.getLocation(), viewSizesToLoopsMap,
                           viewSizes, tileSizes, folder);
   if (!permutation.empty())
     applyPermutationToVector(loopRanges, permutation);
 
   // 3. Create the tiled loops.
   LinalgOp res = op;
-  auto ivs = ValueHandle::makeIndexHandles(loopRanges.size());
-  auto pivs = makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
+  SmallVector<Value, 4> ivs(loopRanges.size());
   // Convert SubViewOp::Range to linalg_range.
   SmallVector<Value, 4> linalgRanges;
   for (auto &range : loopRanges) {
     linalgRanges.push_back(
         linalg_range(range.offset, range.size, range.stride));
   }
-  GenericLoopNestRangeBuilder<LoopTy>(pivs, linalgRanges)([&] {
+  GenericLoopNestRangeBuilder<LoopTy>(ivs, linalgRanges)([&] {
     auto b = ScopedContext::getBuilder();
     auto loc = ScopedContext::getLocation();
     SmallVector<Value, 4> ivValues(ivs.begin(), ivs.end());
 
     // If we have to apply a permutation to the tiled loop nest, we have to
     // reorder the induction variables This permutation is the right one
     // assuming that loopRanges have previously been permuted by
     // (i,j,k)->(k,i,j) So this permutation should be the inversePermutation of
     // that one: (d0,d1,d2)->(d2,d0,d1)
     if (!permutation.empty())
       ivValues = applyMapToValues(b, loc, invPermutationMap, ivValues, folder);
 
     auto views =
         makeTiledViews(b, loc, op, ivValues, tileSizes, viewSizes, folder);
     auto operands = getAssumedNonViewOperands(op);
     views.append(operands.begin(), operands.end());
     res = op.clone(b, loc, views);
   });
 
   // 4. Transforms index arguments of `linalg.generic` w.r.t. to the tiling.
-  transformIndexedGenericOpIndices(b, res, pivs, loopIndexToRangeIndex);
+  transformIndexedGenericOpIndices(b, res, ivs, loopIndexToRangeIndex);
 
   // 5. Gather the newly created loops and return them with the new op.
   SmallVector<Operation *, 8> loops;
   loops.reserve(ivs.size());
   for (auto iv : ivs)
     loops.push_back(loop::getForInductionVarOwner(iv));
 
   return TiledLinalgOp{res, loops};

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

 //===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
 //
 // 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/LoopOps/EDSC/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
 mlir::edsc::ParallelLoopNestBuilder::ParallelLoopNestBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-    ArrayRef<ValueHandle> ubs, ArrayRef<ValueHandle> steps) {
+    MutableArrayRef<Value> ivs, ArrayRef<Value> lbs, ArrayRef<Value> ubs,
+    ArrayRef<Value> steps) {
   assert(ivs.size() == lbs.size() && "Mismatch in number of arguments");
   assert(ivs.size() == ubs.size() && "Mismatch in number of arguments");
   assert(ivs.size() == steps.size() && "Mismatch in number of arguments");
 
   loops.emplace_back(makeParallelLoopBuilder(ivs, lbs, ubs, steps));
 }
 
 void mlir::edsc::ParallelLoopNestBuilder::operator()(
     function_ref<void(void)> fun) {
   if (fun)
     fun();
   // Iterate on the calling operator() on all the loops in the nest.
   // The iteration order is from innermost to outermost because enter/exit needs
   // to be asymmetric (i.e. enter() occurs on LoopBuilder construction, exit()
   // occurs on calling operator()). The asymmetry is required for properly
   // nesting imperfectly nested regions (see LoopBuilder::operator()).
   for (auto lit = loops.rbegin(), eit = loops.rend(); lit != eit; ++lit)
     (*lit)();
 }
 
-mlir::edsc::LoopNestBuilder::LoopNestBuilder(ArrayRef<ValueHandle *> ivs,
-                                             ArrayRef<ValueHandle> lbs,
-                                             ArrayRef<ValueHandle> ubs,
-                                             ArrayRef<ValueHandle> steps) {
+mlir::edsc::LoopNestBuilder::LoopNestBuilder(MutableArrayRef<Value> ivs,
+                                             ArrayRef<Value> lbs,
+                                             ArrayRef<Value> ubs,
+                                             ArrayRef<Value> steps) {
   assert(ivs.size() == lbs.size() && "expected size of ivs and lbs to match");
   assert(ivs.size() == ubs.size() && "expected size of ivs and ubs to match");
   assert(ivs.size() == steps.size() &&
          "expected size of ivs and steps to match");
   loops.reserve(ivs.size());
   for (auto it : llvm::zip(ivs, lbs, ubs, steps))
-    loops.emplace_back(makeLoopBuilder(std::get<0>(it), std::get<1>(it),
+    loops.emplace_back(makeLoopBuilder(&std::get<0>(it), std::get<1>(it),
                                        std::get<2>(it), std::get<3>(it)));
   assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
 }
 
 mlir::edsc::LoopNestBuilder::LoopNestBuilder(
-    ValueHandle *iv, ValueHandle lb, ValueHandle ub, ValueHandle step,
-    ArrayRef<ValueHandle *> iter_args_handles,
-    ValueRange iter_args_init_values) {
-  assert(iter_args_init_values.size() == iter_args_handles.size() &&
+    Value *iv, Value lb, Value ub, Value step,
+    MutableArrayRef<Value> iterArgsHandles, ValueRange iterArgsInitValues) {
+  assert(iterArgsInitValues.size() == iterArgsHandles.size() &&
          "expected size of arguments and argument_handles to match");
-  loops.emplace_back(makeLoopBuilder(iv, lb, ub, step, iter_args_handles,
-                                     iter_args_init_values));
+  loops.emplace_back(
+      makeLoopBuilder(iv, lb, ub, step, iterArgsHandles, iterArgsInitValues));
+}
+
+mlir::edsc::LoopNestBuilder::LoopNestBuilder(Value *iv, Value lb, Value ub,
+                                             Value step) {
+  SmallVector<Value, 0> noArgs;
+  loops.emplace_back(makeLoopBuilder(iv, lb, ub, step, noArgs, {}));
 }
 
 Operation::result_range
 mlir::edsc::LoopNestBuilder::LoopNestBuilder::operator()(
     std::function<void(void)> fun) {
   if (fun)
     fun();
 
   for (auto &lit : reverse(loops))
     lit({});
 
   return loops[0].getOp()->getResults();
 }
 
-LoopBuilder mlir::edsc::makeParallelLoopBuilder(ArrayRef<ValueHandle *> ivs,
-                                                ArrayRef<ValueHandle> lbHandles,
-                                                ArrayRef<ValueHandle> ubHandles,
-                                                ArrayRef<ValueHandle> steps) {
+LoopBuilder mlir::edsc::makeParallelLoopBuilder(MutableArrayRef<Value> ivs,
+                                                ArrayRef<Value> lbHandles,
+                                                ArrayRef<Value> ubHandles,
+                                                ArrayRef<Value> steps) {
   LoopBuilder result;
   auto opHandle = OperationHandle::create<loop::ParallelOp>(
       SmallVector<Value, 4>(lbHandles.begin(), lbHandles.end()),
       SmallVector<Value, 4>(ubHandles.begin(), ubHandles.end()),
       SmallVector<Value, 4>(steps.begin(), steps.end()));
 
   loop::ParallelOp parallelOp =
       cast<loop::ParallelOp>(*opHandle.getOperation());
   for (size_t i = 0, e = ivs.size(); i < e; ++i)
-    *ivs[i] = ValueHandle(parallelOp.getBody()->getArgument(i));
+    ivs[i] = parallelOp.getBody()->getArgument(i);
   result.enter(parallelOp.getBody(), /*prev=*/1);
   return result;
 }
 
-mlir::edsc::LoopBuilder
-mlir::edsc::makeLoopBuilder(ValueHandle *iv, ValueHandle lbHandle,
-                            ValueHandle ubHandle, ValueHandle stepHandle,
-                            ArrayRef<ValueHandle *> iter_args_handles,
-                            ValueRange iter_args_init_values) {
+mlir::edsc::LoopBuilder mlir::edsc::makeLoopBuilder(
+    Value *iv, Value lbHandle, Value ubHandle, Value stepHandle,
+    MutableArrayRef<Value> iterArgsHandles, ValueRange iterArgsInitValues) {
   mlir::edsc::LoopBuilder result;
   auto forOp = OperationHandle::createOp<loop::ForOp>(
-      lbHandle, ubHandle, stepHandle, iter_args_init_values);
-  *iv = ValueHandle(forOp.getInductionVar());
-  auto *body = loop::getForInductionVarOwner(iv->getValue()).getBody();
-  for (size_t i = 0, e = iter_args_handles.size(); i < e; ++i) {
+      lbHandle, ubHandle, stepHandle, iterArgsInitValues);
+  *iv = forOp.getInductionVar();
+  auto *body = loop::getForInductionVarOwner(*iv).getBody();
+  for (size_t i = 0, e = iterArgsHandles.size(); i < e; ++i) {
     // Skipping the induction variable.
-    *(iter_args_handles[i]) = ValueHandle(body->getArgument(i + 1));
+    iterArgsHandles[i] = body->getArgument(i + 1);
   }
   result.setOp(forOp);
   result.enter(body, /*prev=*/1);
   return result;
 }

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

 //===- Builders.cpp - MLIR Declarative Builder Classes --------------------===//
 //
 // 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"
 #include "mlir/IR/AffineMap.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 
-static SmallVector<ValueHandle, 8> getMemRefSizes(Value memRef) {
+static SmallVector<Value, 8> getMemRefSizes(Value memRef) {
   MemRefType memRefType = memRef.getType().cast<MemRefType>();
   assert(isStrided(memRefType) && "Expected strided MemRef type");
 
-  SmallVector<ValueHandle, 8> res;
+  SmallVector<Value, 8> res;
   res.reserve(memRefType.getShape().size());
   const auto &shape = memRefType.getShape();
   for (unsigned idx = 0, n = shape.size(); idx < n; ++idx) {
     if (shape[idx] == -1)
       res.push_back(std_dim(memRef, idx));
     else
       res.push_back(std_constant_index(shape[idx]));
   }

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<ValueHandle> operands) {
+                                               ArrayRef<Value> operands) {
   assert(bh && "Expected already captured BlockHandle");
   for (auto &o : operands) {
     (void)o;
-    assert(o && "Expected already captured ValueHandle");
+    assert(o && "Expected already captured Value");
   }
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
   return OperationHandle::create<BranchOp>(bh.getBlock(), ops);
 }
 
-static void enforceEmptyCapturesMatchOperands(ArrayRef<ValueHandle *> captures,
-                                              ArrayRef<ValueHandle> operands) {
-  assert(captures.size() == operands.size() &&
-         "Expected same number of captures as operands");
-  for (auto it : llvm::zip(captures, operands)) {
-    (void)it;
-    assert(!std::get<0>(it)->hasValue() &&
-           "Unexpected already captured ValueHandle");
-    assert(std::get<1>(it) && "Expected already captured ValueHandle");
-    assert(std::get<0>(it)->getType() == std::get<1>(it).getType() &&
-           "Expected the same type for capture and operand");
-  }
-}
-
 OperationHandle mlir::edsc::intrinsics::std_br(BlockHandle *bh,
-                                               ArrayRef<ValueHandle *> captures,
-                                               ArrayRef<ValueHandle> operands) {
+                                               ArrayRef<Type> types,
+                                               MutableArrayRef<Value> captures,
+                                               ArrayRef<Value> operands) {
   assert(!*bh && "Unexpected already captured BlockHandle");
-  enforceEmptyCapturesMatchOperands(captures, operands);
-  BlockBuilder(bh, captures)(/* no body */);
+  BlockBuilder(bh, types, captures)(/* no body */);
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
   return OperationHandle::create<BranchOp>(bh->getBlock(), ops);
 }
 
-OperationHandle
-mlir::edsc::intrinsics::std_cond_br(ValueHandle cond, BlockHandle trueBranch,
-                                    ArrayRef<ValueHandle> trueOperands,
-                                    BlockHandle falseBranch,
-                                    ArrayRef<ValueHandle> falseOperands) {
+OperationHandle mlir::edsc::intrinsics::std_cond_br(
+    Value cond, BlockHandle trueBranch, ArrayRef<Value> trueOperands,
+    BlockHandle falseBranch, ArrayRef<Value> 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);
 }
 
 OperationHandle mlir::edsc::intrinsics::std_cond_br(
-    ValueHandle cond, BlockHandle *trueBranch,
-    ArrayRef<ValueHandle *> trueCaptures, ArrayRef<ValueHandle> trueOperands,
-    BlockHandle *falseBranch, ArrayRef<ValueHandle *> falseCaptures,
-    ArrayRef<ValueHandle> falseOperands) {
+    Value cond, BlockHandle *trueBranch, ArrayRef<Type> trueTypes,
+    MutableArrayRef<Value> trueCaptures, ArrayRef<Value> trueOperands,
+    BlockHandle *falseBranch, ArrayRef<Type> falseTypes,
+    MutableArrayRef<Value> falseCaptures, ArrayRef<Value> falseOperands) {
   assert(!*trueBranch && "Unexpected already captured BlockHandle");
   assert(!*falseBranch && "Unexpected already captured BlockHandle");
-  enforceEmptyCapturesMatchOperands(trueCaptures, trueOperands);
-  enforceEmptyCapturesMatchOperands(falseCaptures, falseOperands);
-  BlockBuilder(trueBranch, trueCaptures)(/* no body */);
-  BlockBuilder(falseBranch, falseCaptures)(/* no body */);
+  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);
 }

mlir/lib/EDSC/Builders.cpp

assert(ScopedContext::getCurrentScopedContext() &&
          "Unexpected Null ScopedContext");
   return ScopedContext::getCurrentScopedContext()->location;
 }
 
 MLIRContext *mlir::edsc::ScopedContext::getContext() {
   return getBuilder().getContext();
 }
 
-ValueHandle &mlir::edsc::ValueHandle::operator=(const ValueHandle &other) {
-  assert(t == other.t && "Wrong type capture");
-  assert(!v && "ValueHandle has already been captured, use a new name!");
-  v = other.v;
-  return *this;
-}
-
-ValueHandle ValueHandle::create(StringRef name, ArrayRef<ValueHandle> operands,
-                                ArrayRef<Type> resultTypes,
-                                ArrayRef<NamedAttribute> attributes) {
-  Operation *op =
-      OperationHandle::create(name, operands, resultTypes, attributes);
-  if (op->getNumResults() == 1)
-    return ValueHandle(op->getResult(0));
-  llvm_unreachable("unsupported operation, use an OperationHandle instead");
-}
-
 OperationHandle OperationHandle::create(StringRef name,
-                                        ArrayRef<ValueHandle> operands,
+                                        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);
void mlir::edsc::LoopBuilder::operator()(function_ref<void(void)> fun) {
   exit();
 }
 
 mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle bh, Append) {
   assert(bh && "Expected already captured BlockHandle");
   enter(bh.getBlock());
 }
 
-mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle *bh,
-                                       ArrayRef<ValueHandle *> args) {
+mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle *bh, ArrayRef<Type> types,
+                                       MutableArrayRef<Value> args) {
   assert(!*bh && "BlockHandle already captures a block, use "
                  "the explicit BockBuilder(bh, Append())({}) syntax instead.");
-  SmallVector<Type, 8> types;
-  for (auto *a : args) {
-    assert(!a->hasValue() &&
-           "Expected delayed ValueHandle that has not yet captured.");
-    types.push_back(a->getType());
-  }
+  assert((args.empty() || args.size() == types.size()) &&
+         "if args captures are specified, their number must match the number "
+         "of types");
   *bh = BlockHandle::create(types);
-  for (auto it : llvm::zip(args, bh->getBlock()->getArguments())) {
-    *(std::get<0>(it)) = ValueHandle(std::get<1>(it));
-  }
+  if (!args.empty())
+    for (auto it : llvm::zip(args, bh->getBlock()->getArguments()))
+      std::get<0>(it) = Value(std::get<1>(it));
   enter(bh->getBlock());
 }
 
 mlir::edsc::BlockBuilder::BlockBuilder(BlockHandle *bh, Region &region,
-                                       ArrayRef<ValueHandle *> args) {
+                                       ArrayRef<Type> types,
+                                       MutableArrayRef<Value> args) {
   assert(!*bh && "BlockHandle already captures a block, use "
                  "the explicit BockBuilder(bh, Append())({}) syntax instead.");
-  SmallVector<Type, 8> types;
-  for (auto *a : args) {
-    assert(!a->hasValue() &&
-           "Expected delayed ValueHandle that has not yet captured.");
-    types.push_back(a->getType());
-  }
+  assert((args.empty() || args.size() == types.size()) &&
+         "if args captures are specified, their number must match the number "
+         "of types");
   *bh = BlockHandle::createInRegion(region, types);
-  for (auto it : llvm::zip(args, bh->getBlock()->getArguments())) {
-    *(std::get<0>(it)) = ValueHandle(std::get<1>(it));
-  }
+  if (!args.empty())
+    for (auto it : llvm::zip(args, bh->getBlock()->getArguments()))
+      std::get<0>(it) = Value(std::get<1>(it));
   enter(bh->getBlock());
 }
 
 /// Only serves as an ordering point between entering nested block and creating
 /// stmts.
 void mlir::edsc::BlockBuilder::operator()(function_ref<void(void)> fun) {
   // Call to `exit` must be explicit and asymmetric (cannot happen in the
   // destructor) because of ordering wrt comma operator.
   if (fun)
     fun();
   exit();
 }

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

 TEST_FUNC(builder_dynamic_for_func_args) {
   auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto f =
       makeFunction("builder_dynamic_for_func_args", {}, {indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle i(indexType), j(indexType), lb(f.getArgument(0)),
-      ub(f.getArgument(1));
-  ValueHandle f7(std_constant_float(llvm::APFloat(7.0f), f32Type));
-  ValueHandle f13(std_constant_float(llvm::APFloat(13.0f), f32Type));
-  ValueHandle i7(std_constant_int(7, 32));
-  ValueHandle i13(std_constant_int(13, 32));
+  Value i, j, lb(f.getArgument(0)), ub(f.getArgument(1));
+  Value f7(std_constant_float(llvm::APFloat(7.0f), f32Type));
+  Value f13(std_constant_float(llvm::APFloat(13.0f), f32Type));
+  Value i7(std_constant_int(7, 32));
+  Value i13(std_constant_int(13, 32));
   AffineLoopNestBuilder(&i, lb, ub, 3)([&] {
     using namespace edsc::op;
     lb *std_constant_index(3) + ub;
     lb + std_constant_index(3);
     AffineLoopNestBuilder(&j, lb, ub, 2)([&] {
       ceilDiv(std_constant_index(31) * floorDiv(i + j * std_constant_index(3),
                                                 std_constant_index(32)),
               std_constant_index(32));

 
 TEST_FUNC(builder_dynamic_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_dynamic_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle i(indexType), a(f.getArgument(0)), b(f.getArgument(1)),
-      c(f.getArgument(2)), d(f.getArgument(3));
+  Value i, a(f.getArgument(0)), b(f.getArgument(1)), c(f.getArgument(2)),
+      d(f.getArgument(3));
   using namespace edsc::op;
   AffineLoopNestBuilder(&i, a - b, c + d, 2)();
 
   // clang-format off
   // CHECK-LABEL: func @builder_dynamic_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT:   affine.for %{{.*}} = affine_map<(d0) -> (d0)>([[r0]]) to affine_map<(d0) -> (d0)>([[r1]]) step 2 {
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_loop_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_loop_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle i(indexType), a(f.getArgument(0)), b(f.getArgument(1)),
-      c(f.getArgument(2)), d(f.getArgument(3));
+  Value i, a(f.getArgument(0)), b(f.getArgument(1)), c(f.getArgument(2)),
+      d(f.getArgument(3));
   using namespace edsc::op;
   LoopNestBuilder(&i, a - b, c + d, a)();
 
   // clang-format off
   // CHECK-LABEL: func @builder_loop_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT:   loop.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} {
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_max_min_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_max_min_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle i(indexType), lb1(f.getArgument(0)), lb2(f.getArgument(1)),
-      ub1(f.getArgument(2)), ub2(f.getArgument(3));
+  Value i, lb1(f.getArgument(0)), lb2(f.getArgument(1)), ub1(f.getArgument(2)),
+      ub2(f.getArgument(3));
   AffineLoopNestBuilder(&i, {lb1, lb2}, {ub1, ub2}, 1)();
   std_ret();
 
   // clang-format off
   // CHECK-LABEL: func @builder_max_min_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK:  affine.for %{{.*}} = max affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) {
   // CHECK:  return
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_blocks) {
   using namespace edsc::op;
   auto f = makeFunction("builder_blocks");
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle c1(ValueHandle::create<ConstantIntOp>(42, 32)),
-      c2(ValueHandle::create<ConstantIntOp>(1234, 32));
-  ValueHandle arg1(c1.getType()), arg2(c1.getType()), arg3(c1.getType()),
-      arg4(c1.getType()), r(c1.getType());
-
+  Value c1(std_constant_int(42, 32)), c2(std_constant_int(1234, 32));
+  Value r;
+  Value args12[2];
+  Value &arg1 = args12[0], &arg2 = args12[1];
+  Value args34[2];
+  Value &arg3 = args34[0], &arg4 = args34[1];
   BlockHandle b1, b2, functionBlock(&f.front());
-  BlockBuilder(&b1, {&arg1, &arg2})(
+  BlockBuilder(&b1, {c1.getType(), c1.getType()}, args12)(
       // b2 has not yet been constructed, need to come back later.
       // This is a byproduct of non-structured control-flow.
   );
-  BlockBuilder(&b2, {&arg3, &arg4})([&] { std_br(b1, {arg3, arg4}); });
+  BlockBuilder(&b2, {c1.getType(), c1.getType()}, args34)([&] {
+    std_br(b1, {arg3, arg4});
+  });
   // The insertion point within the toplevel function is now past b2, we will
   // need to get back the entry block.
   // This is what happens with unstructured control-flow..
   BlockBuilder(b1, Append())([&] {
     r = arg1 + arg2;
     std_br(b2, {arg1, r});
   });
   // Get back to entry block and add a branch into b1

 }
 
 TEST_FUNC(builder_blocks_eager) {
   using namespace edsc::op;
   auto f = makeFunction("builder_blocks_eager");
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle c1(ValueHandle::create<ConstantIntOp>(42, 32)),
-      c2(ValueHandle::create<ConstantIntOp>(1234, 32));
-  ValueHandle arg1(c1.getType()), arg2(c1.getType()), arg3(c1.getType()),
-      arg4(c1.getType()), r(c1.getType());
+  Value c1(std_constant_int(42, 32)), c2(std_constant_int(1234, 32));
+  Value res;
+  Value args1And2[2], args3And4[2];
+  Value &arg1 = args1And2[0], &arg2 = args1And2[1], &arg3 = args3And4[0],
+        &arg4 = args3And4[1];
 
   // clang-format off
   BlockHandle b1, b2;
   { // Toplevel function scope.
     // Build a new block for b1 eagerly.
-    std_br(&b1, {&arg1, &arg2}, {c1, c2});
+    std_br(&b1, {c1.getType(), c1.getType()}, args1And2, {c1, c2});
     // Construct a new block b2 explicitly with a branch into b1.
-    BlockBuilder(&b2, {&arg3, &arg4})([&]{
+    BlockBuilder(&b2, {c1.getType(), c1.getType()}, args3And4)([&]{
         std_br(b1, {arg3, arg4});
     });
     /// And come back to append into b1 once b2 exists.
     BlockBuilder(b1, Append())([&]{
-        r = arg1 + arg2;
-        std_br(b2, {arg1, r});
+        res = arg1 + arg2;
+        std_br(b2, {arg1, res});
     });
   }
 
   // CHECK-LABEL: @builder_blocks_eager
   // CHECK:        %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   %{{.*}} = constant 1234 : i32
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32):   // 2 preds: ^bb0, ^bb2
   // CHECK-NEXT:   %{{.*}} = addi %{{.*}}, %{{.*}} : i32
   // CHECK-NEXT:   br ^bb2(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32):   // pred: ^bb1
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: }
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_cond_branch) {
   auto f = makeFunction("builder_cond_branch", {},
                         {IntegerType::get(1, &globalContext())});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle funcArg(f.getArgument(0));
-  ValueHandle c32(ValueHandle::create<ConstantIntOp>(32, 32)),
-      c64(ValueHandle::create<ConstantIntOp>(64, 64)),
-      c42(ValueHandle::create<ConstantIntOp>(42, 32));
-  ValueHandle arg1(c32.getType()), arg2(c64.getType()), arg3(c32.getType());
-
+  Value funcArg(f.getArgument(0));
+  Value c32(std_constant_int(32, 32)), c64(std_constant_int(64, 64)),
+      c42(std_constant_int(42, 32));
+  Value arg1;
+  Value args23[2];
   BlockHandle b1, b2, functionBlock(&f.front());
-  BlockBuilder(&b1, {&arg1})([&] { std_ret(); });
-  BlockBuilder(&b2, {&arg2, &arg3})([&] { std_ret(); });
+  BlockBuilder(&b1, c32.getType(), arg1)([&] { std_ret(); });
+  BlockBuilder(&b2, {c64.getType(), c32.getType()}, args23)([&] { std_ret(); });
   // Get back to entry block and add a conditional branch
   BlockBuilder(functionBlock, Append())([&] {
     std_cond_br(funcArg, b1, {c32}, b2, {c64, c42});
   });
 
   // clang-format off
   // CHECK-LABEL: @builder_cond_branch
   // CHECK:   %{{.*}} = constant 32 : i32

 
 TEST_FUNC(builder_cond_branch_eager) {
   using namespace edsc::op;
   auto f = makeFunction("builder_cond_branch_eager", {},
                         {IntegerType::get(1, &globalContext())});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle funcArg(f.getArgument(0));
-  ValueHandle c32(ValueHandle::create<ConstantIntOp>(32, 32)),
-      c64(ValueHandle::create<ConstantIntOp>(64, 64)),
-      c42(ValueHandle::create<ConstantIntOp>(42, 32));
-  ValueHandle arg1(c32.getType()), arg2(c64.getType()), arg3(c32.getType());
+  Value arg0(f.getArgument(0));
+  Value c32(std_constant_int(32, 32)), c64(std_constant_int(64, 64)),
+      c42(std_constant_int(42, 32));
 
   // clang-format off
   BlockHandle b1, b2;
-  std_cond_br(funcArg, &b1, {&arg1}, {c32}, &b2, {&arg2, &arg3}, {c64, c42});
+  Value arg1[1], args2And3[2];
+  std_cond_br(arg0,
+              &b1, c32.getType(), arg1, c32,
+              &b2, {c64.getType(), c32.getType()}, args2And3, {c64, c42});
   BlockBuilder(b1, Append())([]{
       std_ret();
   });
   BlockBuilder(b2, Append())([]{
       std_ret();
   });
 
   // CHECK-LABEL: @builder_cond_branch_eager
   // CHECK:   %{{.*}} = constant 32 : i32
   // CHECK-NEXT:   %{{.*}} = constant 64 : i64
   // CHECK-NEXT:   %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}}, %{{.*}} : i64, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32):   // pred: ^bb0
   // CHECK-NEXT:   return
   // CHECK-NEXT: ^bb2(%{{.*}}: i64, %{{.*}}: i32):  // pred: ^bb0
   // CHECK-NEXT:   return
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_helpers) {
   using namespace edsc::op;
-  auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
                        ShapedType::kDynamicSize},
                       f32Type, {}, 0);
   auto f =
       makeFunction("builder_helpers", {}, {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   // clang-format off
-  ValueHandle f7(
-      ValueHandle::create<ConstantFloatOp>(llvm::APFloat(7.0f), f32Type));
+  Value f7 = std_constant_float(llvm::APFloat(7.0f), f32Type);
   MemRefBoundsCapture vA(f.getArgument(0)), vB(f.getArgument(1)),
       vC(f.getArgument(2));
   AffineIndexedValue A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
-  ValueHandle i(indexType), j(indexType), k1(indexType), k2(indexType),
-      lb0(indexType), lb1(indexType), lb2(indexType),
-      ub0(indexType), ub1(indexType), ub2(indexType);
+  Value ivs[2];
+  Value &i = ivs[0], &j = ivs[1];
+  Value k1, k2, lb0, lb1, lb2, ub0, ub1, ub2;
   int64_t step0, step1, step2;
   std::tie(lb0, ub0, step0) = vA.range(0);
   std::tie(lb1, ub1, step1) = vA.range(1);
   lb2 = vA.lb(2);
   ub2 = vA.ub(2);
   step2 = vA.step(2);
-  AffineLoopNestBuilder({&i, &j}, {lb0, lb1}, {ub0, ub1}, {step0, step1})([&]{
+  AffineLoopNestBuilder(ivs, {lb0, lb1}, {ub0, ub1}, {step0, step1})([&]{
     AffineLoopNestBuilder(&k1, lb2, ub2, step2)([&]{
       C(i, j, k1) = f7 + A(i, j, k1) + B(i, j, k1);
     });
     AffineLoopNestBuilder(&k2, lb2, ub2, step2)([&]{
       C(i, j, k2) += A(i, j, k2) + B(i, j, k2);
     });
   });
 
TEST_FUNC(builder_helpers) {
   //  CHECK-DAG:         [[d:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[e:%.*]] = addf [[d]], [[c]] : f32
   // CHECK-NEXT:         affine.store [[e]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
-TEST_FUNC(custom_ops) {
-  using namespace edsc::op;
-  auto indexType = IndexType::get(&globalContext());
-  auto f = makeFunction("custom_ops", {}, {indexType, indexType});
-
-  OpBuilder builder(f.getBody());
-  ScopedContext scope(builder, f.getLoc());
-  CustomOperation<ValueHandle> MY_CUSTOM_OP("my_custom_op");
-  CustomOperation<OperationHandle> MY_CUSTOM_OP_0("my_custom_op_0");
-  CustomOperation<OperationHandle> MY_CUSTOM_OP_2("my_custom_op_2");
-
-  // clang-format off
-  ValueHandle vh(indexType), vh20(indexType), vh21(indexType);
-  OperationHandle ih0, ih2;
-  ValueHandle m(indexType), n(indexType);
-  ValueHandle M(f.getArgument(0)), N(f.getArgument(1));
-  ValueHandle ten(std_constant_index(10)), twenty(std_constant_index(20));
-  AffineLoopNestBuilder({&m, &n}, {M, N}, {M + ten, N + twenty}, {1, 1})([&]{
-    vh = MY_CUSTOM_OP({m, m + n}, {indexType}, {});
-    ih0 = MY_CUSTOM_OP_0({m, m + n}, {});
-    ih2 = MY_CUSTOM_OP_2({m, m + n}, {indexType, indexType});
-    // These captures are verbose for now, can improve when used in practice.
-    vh20 = ValueHandle(ih2.getOperation()->getResult(0));
-    vh21 = ValueHandle(ih2.getOperation()->getResult(1));
-    MY_CUSTOM_OP({vh20, vh21}, {indexType}, {});
-  });
-
-  // CHECK-LABEL: @custom_ops
-  // CHECK: affine.for %{{.*}} {{.*}}
-  // CHECK:   affine.for %{{.*}} {{.*}}
-  // CHECK:     {{.*}} = "my_custom_op"{{.*}} : (index, index) -> index
-  // CHECK:     "my_custom_op_0"{{.*}} : (index, index) -> ()
-  // CHECK:     [[TWO:%[a-z0-9]+]]:2 = "my_custom_op_2"{{.*}} : (index, index) -> (index, index)
-  // CHECK:     {{.*}} = "my_custom_op"([[TWO]]#0, [[TWO]]#1) : (index, index) -> index
-  // clang-format on
-  f.print(llvm::outs());
-  f.erase();
-}
-
 TEST_FUNC(insertion_in_block) {
   using namespace edsc::op;
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("insertion_in_block", {}, {indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   BlockHandle b1;
   // clang-format off
-  ValueHandle::create<ConstantIntOp>(0, 32);
-  BlockBuilder(&b1, {})([]{
-    ValueHandle::create<ConstantIntOp>(1, 32);
+  std_constant_int(0, 32);
+  (BlockBuilder(&b1))([]{
+    std_constant_int(1, 32);
   });
-  ValueHandle::create<ConstantIntOp>(2, 32);
+  std_constant_int(2, 32);
   // CHECK-LABEL: @insertion_in_block
   // CHECK: {{.*}} = constant 0 : i32
   // CHECK: {{.*}} = constant 2 : i32
   // CHECK: ^bb1:   // no predecessors
   // CHECK: {{.*}} = constant 1 : i32
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(zero_and_std_sign_extendi_op_i1_to_i8) {
   using namespace edsc::op;
   auto i1Type = IntegerType::get(1, &globalContext());
   auto i8Type = IntegerType::get(8, &globalContext());
   auto memrefType = MemRefType::get({}, i1Type, {}, 0);
   auto f = makeFunction("zero_and_std_sign_extendi_op", {},
                         {memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   AffineIndexedValue A(f.getArgument(0));
   AffineIndexedValue B(f.getArgument(1));
   // clang-format off
-  edsc::intrinsics::std_zero_extendi(*A, i8Type);
-  edsc::intrinsics::std_sign_extendi(*B, i8Type);
+  edsc::intrinsics::std_zero_extendi(A, i8Type);
+  edsc::intrinsics::std_sign_extendi(B, i8Type);
   // CHECK-LABEL: @zero_and_std_sign_extendi_op
   //      CHECK:     %[[SRC1:.*]] = affine.load
   //      CHECK:     zexti %[[SRC1]] : i1 to i8
   //      CHECK:     %[[SRC2:.*]] = affine.load
   //      CHECK:     sexti %[[SRC2]] : i1 to i8
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(operator_or) {
   auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
   auto f = makeFunction("operator_or", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator||;
-  ValueHandle lhs(f.getArgument(0));
-  ValueHandle rhs(f.getArgument(1));
+  Value lhs(f.getArgument(0));
+  Value rhs(f.getArgument(1));
   lhs || rhs;
 
   // CHECK-LABEL: @operator_or
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: or [[ARG0]], [[ARG1]]
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(operator_and) {
   auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
   auto f = makeFunction("operator_and", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator&&;
-  ValueHandle lhs(f.getArgument(0));
-  ValueHandle rhs(f.getArgument(1));
+  Value lhs(f.getArgument(0));
+  Value rhs(f.getArgument(1));
   lhs &&rhs;
 
   // CHECK-LABEL: @operator_and
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: and [[ARG0]], [[ARG1]]
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(select_op_i32) {
   using namespace edsc::op;
-  auto indexType = IndexType::get(&globalContext());
   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());
   ScopedContext scope(builder, f.getLoc());
   // clang-format off
-  ValueHandle zero = std_constant_index(0), one = std_constant_index(1);
+  Value zero = std_constant_index(0), one = std_constant_index(1);
   MemRefBoundsCapture vA(f.getArgument(0));
   AffineIndexedValue A(f.getArgument(0));
-  ValueHandle i(indexType), j(indexType);
-  AffineLoopNestBuilder({&i, &j}, {zero, zero}, {one, one}, {1, 1})([&]{
-    // This test exercises AffineIndexedValue::operator Value.
-    // Without it, one must force conversion to ValueHandle as such:
-    //   std_select(
-    //      i == zero, ValueHandle(A(zero, zero)), ValueHandle(ValueA(i, j)))
-    using edsc::op::operator==;
-    std_select(i == zero, *A(zero, zero), *A(i, j));
+  Value ivs[2];
+  Value &i = ivs[0], &j = ivs[1];
+  AffineLoopNestBuilder(ivs, {zero, zero}, {one, one}, {1, 1})([&]{
+    std_select(eq(i, zero), A(zero, zero), A(i, j));
   });
 
   // CHECK-LABEL: @select_op
   //      CHECK: affine.for %{{.*}} = 0 to 1 {
   // CHECK-NEXT:   affine.for %{{.*}} = 0 to 1 {
   //  CHECK-DAG:     {{.*}} = cmpi "eq"
   //  CHECK-DAG:     {{.*}} = affine.load
   //  CHECK-DAG:     {{.*}} = affine.load
   // CHECK-NEXT:     {{.*}} = select
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(select_op_f32) {
-  auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("select_op", {}, {memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   // clang-format off
-  ValueHandle zero = std_constant_index(0), one = std_constant_index(1);
+  Value zero = std_constant_index(0), one = std_constant_index(1);
   MemRefBoundsCapture vA(f.getArgument(0)), vB(f.getArgument(1));
   AffineIndexedValue A(f.getArgument(0)), B(f.getArgument(1));
-  ValueHandle i(indexType), j(indexType);
-  AffineLoopNestBuilder({&i, &j}, {zero, zero}, {one, one}, {1, 1})([&]{
+  Value ivs[2];
+  Value &i = ivs[0], &j = ivs[1];
+  AffineLoopNestBuilder(ivs, {zero, zero}, {one, one}, {1, 1})([&]{
     using namespace edsc::op;
-    std_select(B(i, j) == B(i + one, j), *A(zero, zero), *A(i, j));
-    std_select(B(i, j) != B(i + one, j), *A(zero, zero), *A(i, j));
-    std_select(B(i, j) >= B(i + one, j), *A(zero, zero), *A(i, j));
-    std_select(B(i, j) <= B(i + one, j), *A(zero, zero), *A(i, j));
-    std_select(B(i, j) < B(i + one, j), *A(zero, zero), *A(i, j));
-    std_select(B(i, j) > B(i + one, j), *A(zero, zero), *A(i, j));
+    std_select(eq(B(i, j), B(i + one, j)), A(zero, zero), A(i, j));
+    std_select(ne(B(i, j), B(i + one, j)), A(zero, zero), A(i, j));
+    std_select(B(i, j) >= B(i + one, j), A(zero, zero), A(i, j));
+    std_select(B(i, j) <= B(i + one, j), A(zero, zero), A(i, j));
+    std_select(B(i, j) < B(i + one, j), A(zero, zero), A(i, j));
+    std_select(B(i, j) > B(i + one, j), A(zero, zero), A(i, j));
   });
 
   // CHECK-LABEL: @select_op
   //      CHECK: affine.for %{{.*}} = 0 to 1 {
   // CHECK-NEXT:   affine.for %{{.*}} = 0 to 1 {
   //  CHECK-DAG:     cmpf "oeq"
   //  CHECK-DAG:     affine.load
   //  CHECK-DAG:     affine.load
TEST_FUNC(select_op_f32) {
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 // Inject an EDSC-constructed computation to exercise imperfectly nested 2-d
 // tiling.
 TEST_FUNC(tile_2d) {
-  auto indexType = IndexType::get(&globalContext());
   auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
                        ShapedType::kDynamicSize},
                       FloatType::getF32(&globalContext()), {}, 0);
   auto f = makeFunction("tile_2d", {}, {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle zero = std_constant_index(0);
+  Value zero = std_constant_index(0);
   MemRefBoundsCapture vA(f.getArgument(0)), vB(f.getArgument(1)),
       vC(f.getArgument(2));
   AffineIndexedValue A(f.getArgument(0)), B(f.getArgument(1)),
       C(f.getArgument(2));
-  ValueHandle i(indexType), j(indexType), k1(indexType), k2(indexType);
-  ValueHandle M(vC.ub(0)), N(vC.ub(1)), O(vC.ub(2));
+  Value ivs[2];
+  Value &i = ivs[0], &j = ivs[1];
+  Value k1, k2;
+  Value M(vC.ub(0)), N(vC.ub(1)), O(vC.ub(2));
 
   // clang-format off
   using namespace edsc::op;
-  AffineLoopNestBuilder({&i, &j}, {zero, zero}, {M, N}, {1, 1})([&]{
+  AffineLoopNestBuilder(ivs, {zero, zero}, {M, N}, {1, 1})([&]{
     AffineLoopNestBuilder(&k1, zero, O, 1)([&]{
       C(i, j, k1) = A(i, j, k1) + B(i, j, k1);
     });
     AffineLoopNestBuilder(&k2, zero, O, 1)([&]{
       C(i, j, k2) = A(i, j, k2) + B(i, j, k2);
     });
   });
   // clang-format on
 
-  auto li = getForInductionVarOwner(i.getValue()),
-       lj = getForInductionVarOwner(j.getValue()),
-       lk1 = getForInductionVarOwner(k1.getValue()),
-       lk2 = getForInductionVarOwner(k2.getValue());
+  auto li = getForInductionVarOwner(i), lj = getForInductionVarOwner(j),
+       lk1 = getForInductionVarOwner(k1), lk2 = getForInductionVarOwner(k2);
   auto indicesL1 = mlir::tile({li, lj}, {512, 1024}, {lk1, lk2});
   auto lii1 = indicesL1[0][0], ljj1 = indicesL1[1][0];
   mlir::tile({ljj1, lii1}, {32, 16}, ljj1);
 
   // clang-format off
   // CHECK-LABEL: func @tile_2d
   //       CHECK: %[[ZERO:.*]] = constant 0 : index
   //       CHECK: %[[M:[0-9]+]] = dim %arg2, 0 : memref<?x?x?xf32>
TEST_FUNC(indirect_access) {
   using namespace edsc::op;
   auto memrefType = MemRefType::get({ShapedType::kDynamicSize},
                                     FloatType::getF32(&globalContext()), {}, 0);
   auto f = makeFunction("indirect_access", {},
                         {memrefType, memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle zero = std_constant_index(0);
+  Value zero = std_constant_index(0);
   MemRefBoundsCapture vC(f.getArgument(2));
   AffineIndexedValue B(f.getArgument(1)), D(f.getArgument(3));
   StdIndexedValue A(f.getArgument(0)), C(f.getArgument(2));
-  ValueHandle i(builder.getIndexType()), N(vC.ub(0));
+  Value i, N(vC.ub(0));
 
   // clang-format off
   AffineLoopNestBuilder(&i, zero, N, 1)([&]{
-      C((ValueHandle)D(i)) = A((ValueHandle)B(i));
+      C((Value)D(i)) = A((Value)B(i));
   });
   // clang-format on
 
   // clang-format off
   // CHECK-LABEL: func @indirect_access
   // CHECK-SAME: (%[[ARG0:.*]]: memref<?xf32>, %[[ARG1:.*]]: memref<?xf32>, %[[ARG2:.*]]: memref<?xf32>, %[[ARG3:.*]]: memref<?xf32>)
   // CHECK-DAG:  [[B:%.*]] = affine.load %[[ARG1]]
   // CHECK-DAG:  [[D:%.*]] = affine.load %[[ARG3]]
TEST_FUNC(empty_map_load_store) {
   using namespace edsc::op;
   auto memrefType =
       MemRefType::get({}, FloatType::getF32(&globalContext()), {}, 0);
   auto f = makeFunction("empty_map_load_store", {},
                         {memrefType, memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle zero = std_constant_index(0);
-  ValueHandle one = std_constant_index(1);
+  Value zero = std_constant_index(0);
+  Value one = std_constant_index(1);
   AffineIndexedValue input(f.getArgument(0)), res(f.getArgument(1));
-  ValueHandle iv(builder.getIndexType());
 
   // clang-format off
+  Value iv;
   AffineLoopNestBuilder(&iv, zero, one, 1)([&]{
       res() = input();
   });
   // clang-format on
 
   // clang-format off
   // CHECK-LABEL: func @empty_map_load_store(
   // CHECK:  [[A:%.*]] = affine.load %{{.*}}[]
TEST_FUNC(affine_if_op) {
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("affine_if_op", {}, {memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
-  ValueHandle zero = std_constant_index(0), ten = std_constant_index(10);
+  Value zero = std_constant_index(0), ten = std_constant_index(10);
 
   SmallVector<bool, 4> isEq = {false, false, false, false};
   SmallVector<AffineExpr, 4> affineExprs = {
       builder.getAffineDimExpr(0),    // d0 >= 0
       builder.getAffineDimExpr(1),    // d1 >= 0
       builder.getAffineSymbolExpr(0), // s0 >= 0
       builder.getAffineSymbolExpr(1)  // s1 >= 0
   };
TEST_FUNC(linalg_generic_pointwise_test) {
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("linalg_generic_pointwise", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
+  Value A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
   AffineExpr i, j;
   bindDims(&globalContext(), i, j);
   StructuredIndexed SA(A), SB(B), SC(C);
   linalg_generic_pointwise_add(SA({i, j}), SB({i, j}), SC({i, j}));
   linalg_generic_pointwise_max(SA({i, j}), SB({i, j}), SC({i, j}));
   linalg_generic_pointwise_tanh(SA({i, j}), SC({i, j}));
 
   f.print(llvm::outs());

 // clang-format on
 TEST_FUNC(linalg_generic_matmul_test) {
   using namespace edsc;
   using namespace edsc::ops;
 
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
-  auto f =
-      makeFunction("linalg_generic_matmul", {}, {memrefType, memrefType, memrefType});
+  auto f = makeFunction("linalg_generic_matmul", {},
+                        {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  linalg_generic_matmul(makeValueHandles(llvm::to_vector<3>(f.getArguments())));
+  linalg_generic_matmul(f.getArguments());
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_conv_nhwc
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
                        ShapedType::kDynamicSize, ShapedType::kDynamicSize},
                       f32Type, {}, 0);
   auto f = makeFunction("linalg_generic_conv_nhwc", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  linalg_generic_conv_nhwc(makeValueHandles(llvm::to_vector<3>(f.getArguments())),
+  linalg_generic_conv_nhwc(f.getArguments(),
                            /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_dilated_conv_nhwc
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
                        ShapedType::kDynamicSize, ShapedType::kDynamicSize},
                       f32Type, {}, 0);
   auto f = makeFunction("linalg_generic_dilated_conv_nhwc", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  linalg_generic_dilated_conv_nhwc(makeValueHandles(f.getArguments()),
+  linalg_generic_dilated_conv_nhwc(f.getArguments(),
                                    /*depth_multiplier=*/7,
                                    /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_metadata_ops
 //       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<4x8x16xf32> into memref<32x16xf32>
 //       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<32x16xf32> into memref<4x8x16xf32>
 // clang-format on
 TEST_FUNC(linalg_metadata_ops) {
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get({4, 8, 16}, f32Type, {}, 0);
   auto f = makeFunction("linalg_metadata_ops", {}, {memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   AffineExpr i, j, k;
   bindDims(&globalContext(), i, j, k);
-  ValueHandle v(f.getArgument(0));
+  Value v(f.getArgument(0));
   auto reshaped = linalg_reshape(v, ArrayRef<ArrayRef<AffineExpr>>{{i, j}, k});
   linalg_reshape(memrefType, reshaped,
                  ArrayRef<ArrayRef<AffineExpr>>{{i, j}, k});
 
   f.print(llvm::outs());
   f.erase();
 }
 
TEST_FUNC(linalg_tensors_test) {
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto tensorType = RankedTensorType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type);
   auto f = makeFunction("linalg_tensors", {}, {tensorType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle A(f.getArgument(0)), B(f.getArgument(1));
+  Value A(f.getArgument(0)), B(f.getArgument(1));
   AffineExpr i, j;
   bindDims(&globalContext(), i, j);
   StructuredIndexed SA(A), SB(B), SC(tensorType);
   linalg_generic_pointwise_add(SA({i, j}), SB({i, j}), SC({i, j}));
   linalg_generic_pointwise_max(SA({i, j}), SB({i, j}), SC({i, j}));
   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, ValueHandle(o1), tensorType);
+  linalg_generic_matmul(A, B, o1, tensorType);
 
   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>>,
auto typeB =
                       knVectorType, {}, 0);
   auto typeC =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize},
                       mnVectorType, {}, 0);
   auto f = makeFunction("memref_vector_matmul_test", {}, {typeA, typeB, typeC});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
+  Value A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
   auto contractionBuilder = [](ArrayRef<BlockArgument> args) {
     assert(args.size() == 3 && "expected 3 block arguments");
     (linalg_yield(vector_contraction_matmul(args[0], args[1], args[2])));
   };
   linalg_generic_matmul(A, B, C, contractionBuilder);
 
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_loop_for_yield) {
   auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto f = makeFunction("builder_loop_for_yield", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  ValueHandle init0 = std_constant_float(llvm::APFloat(1.0f), f32Type);
-  ValueHandle init1 = std_constant_float(llvm::APFloat(2.0f), f32Type);
-  ValueHandle i(indexType), a(f.getArgument(0)), b(f.getArgument(1)),
-      c(f.getArgument(2)), d(f.getArgument(3));
-  ValueHandle arg0(f32Type);
-  ValueHandle arg1(f32Type);
+  Value init0 = std_constant_float(llvm::APFloat(1.0f), f32Type);
+  Value init1 = std_constant_float(llvm::APFloat(2.0f), f32Type);
+  Value i, a(f.getArgument(0)), b(f.getArgument(1)), c(f.getArgument(2)),
+      d(f.getArgument(3));
+  Value args01[2];
+  Value &arg0 = args01[0], &arg1 = args01[1];
   using namespace edsc::op;
   auto results =
-      LoopNestBuilder(&i, a - b, c + d, a, {&arg0, &arg1}, {init0, init1})([&] {
+      LoopNestBuilder(&i, a - b, c + d, a, args01, {init0, init1})([&] {
         auto sum = arg0 + arg1;
-        loop_yield(ArrayRef<ValueHandle>{arg1, sum});
+        loop_yield(ArrayRef<Value>{arg1, sum});
       });
-  ValueHandle(results[0]) + ValueHandle(results[1]);
+  results[0] + results[1];
 
   // clang-format off
   // CHECK-LABEL: func @builder_loop_for_yield(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK:     [[init0:%.*]] = constant
   // CHECK:     [[init1:%.*]] = constant
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT: [[res:%[0-9]+]]:2 = loop.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} iter_args([[arg0:%.*]] = [[init0]], [[arg1:%.*]] = [[init1]]) -> (f32, f32) {

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-gen.tc

 //  IMPL-NEXT:  { {{.*}}Parallel{{.*}}, {{.*}}Reduction{{.*}} }
 //
 //       IMPL:  matvec::referenceIndexingMaps() {
 //       IMPL:  AffineMap::get(2, 0, {d0, d1}),
 //  IMPL-NEXT:  AffineMap::get(2, 0, {d1}),
 //  IMPL-NEXT:  AffineMap::get(2, 0, {d0}) };
 //
 //       IMPL:  matvec::regionBuilder(ArrayRef<BlockArgument> args) {
-//       IMPL:  ValueHandle [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
-//       IMPL:  ValueHandle [[d:.*]] = std_mulf([[a]], [[b]]);
-//       IMPL:  ValueHandle [[e:.*]] = std_addf([[c]], [[d]]);
+//       IMPL:  Value [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
+//       IMPL:  Value [[d:.*]] = std_mulf([[a]], [[b]]);
+//       IMPL:  Value [[e:.*]] = std_addf([[c]], [[d]]);
 //       IMPL:  (linalg_yield(ValueRange{ [[e]] }));
 //
 def matvec(A: f32(M, K), B: f32(K)) -> (C: f32(M)) {
   C(m) = std_addf<k>(std_mulf(A(m, k), B(k)));
 }
 
 // ODS-LABEL: def matmulOp : LinalgNamedStructured_Op<"matmul", [
 //  ODS-NEXT:   NInputs<2>,
 //  ODS-NEXT:   NOutputs<1>,
 //  ODS-NEXT:   NamedStructuredOpTraits]>
 //
 // IMPL-LABEL:  matmul::referenceIterators() {
 //  IMPL-NEXT:  { {{.*}}Parallel{{.*}}, {{.*}}Parallel{{.*}}, {{.*}}Reduction{{.*}} }
 //
 //       IMPL:  matmul::referenceIndexingMaps() {
 //       IMPL:  AffineMap::get(3, 0, {d0, d2}),
 //  IMPL-NEXT:  AffineMap::get(3, 0, {d2, d1}),
 //  IMPL-NEXT:  AffineMap::get(3, 0, {d0, d1}) };
 //
 //       IMPL:  matmul::regionBuilder(ArrayRef<BlockArgument> args) {
-//       IMPL:  ValueHandle [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
-//       IMPL:  ValueHandle [[d:.*]] = std_mulf([[a]], [[b]]);
-//       IMPL:  ValueHandle [[e:.*]] = std_addf([[c]], [[d]]);
+//       IMPL:  Value [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
+//       IMPL:  Value [[d:.*]] = std_mulf([[a]], [[b]]);
+//       IMPL:  Value [[e:.*]] = std_addf([[c]], [[d]]);
 //       IMPL:  (linalg_yield(ValueRange{ [[e]] }));
 //
 def matmul(A: f32(M, K), B: f32(K, N)) -> (C: f32(M, N)) {
   C(m, n) = std_addf<k>(std_mulf(A(m, k), B(k, n)));
 }
 
 // ODS-LABEL: def batchmatmulOp : LinalgNamedStructured_Op<"batchmatmul", [
 //  ODS-NEXT:   NInputs<2>,
 //  ODS-NEXT:   NOutputs<1>,
 //  ODS-NEXT:   NamedStructuredOpTraits]>
 //
 // IMPL-LABEL:  batchmatmul::referenceIterators() {
 //  IMPL-NEXT:  { {{.*}}Parallel{{.*}}, {{.*}}Parallel{{.*}}, {{.*}}Reduction{{.*}} }
 //
 //       IMPL:  batchmatmul::referenceIndexingMaps() {
 //       IMPL:  AffineMap::get(4, 0, {d0, d1, d3}),
 //  IMPL-NEXT:  AffineMap::get(4, 0, {d3, d2}),
 //  IMPL-NEXT:  AffineMap::get(4, 0, {d0, d1, d2}) };
 //
 //       IMPL:  batchmatmul::regionBuilder(ArrayRef<BlockArgument> args) {
-//       IMPL:  ValueHandle [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
-//       IMPL:  ValueHandle [[d:.*]] = std_mulf([[a]], [[b]]);
-//       IMPL:  ValueHandle [[e:.*]] = std_addf([[c]], [[d]]);
+//       IMPL:  Value [[a:.*]](args[0]), [[b:.*]](args[1]), [[c:.*]](args[2]);
+//       IMPL:  Value [[d:.*]] = std_mulf([[a]], [[b]]);
+//       IMPL:  Value [[e:.*]] = std_addf([[c]], [[d]]);
 //       IMPL:  (linalg_yield(ValueRange{ [[e]] }));
 //
 //       TBLGEN: batchmatmulOp
 def batchmatmul(A: f32(Batch, M, K), B: f32(K, N)) -> (C: f32(Batch, M, N)) {
   C(b, m, n) = std_addf<k>(std_mulf(A(b, m, k), B(k, n)));
 }

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

printExpr = [&](llvm::raw_ostream &os, const Expression &e) -> void {
     } else {
       std::string subExprs;
       llvm::raw_string_ostream subExprsStringStream(subExprs);
       llvm::interleaveComma(pTensorExpr->expressions, subExprsStringStream,
                             [&](const std::unique_ptr<Expression> &e) {
                               printExpr(subExprsStringStream, *e);
                             });
       subExprsStringStream.flush();
-      const char *tensorExprFmt = "\n    ValueHandle _{0} = {1}({2});";
+      const char *tensorExprFmt = "\n    Value _{0} = {1}({2});";
       os << llvm::formatv(tensorExprFmt, ++count, pTensorExpr->opId, subExprs);
       subExprsMap[pTensorExpr] = count;
     }
   };
 
   const char *regionBuilderFmt = R"FMT(
   void {0}::regionBuilder(ArrayRef<BlockArgument> args) {
     using namespace edsc;
     using namespace intrinsics;
-    ValueHandle {1};
+    Value {1};
     {2}
     (linalg_yield(ValueRange{ {3} }));
   })FMT";
 
   unsigned idx = 0;
   std::string valueHandleStr;
   llvm::raw_string_ostream valueHandleStringStream(valueHandleStr);
   llvm::interleaveComma(