[mlir][EDSC] Almost NFC - Refactor and untangle EDSC dependencies

[nicolasvasilache]

Summary

This CL refactors EDSCs to layer them better and break unnecessary
dependencies. After this refactoring, the top-level EDSC target only
depends on IR but not on Dialects anymore and each dialect has its
own EDSC directory.

This simplifies the layering and breaks cyclic dependencies.
In particular, the declarative builder + folder are made explicit and
are now confined to Linalg.

As the refactoring occurred, certain classes and abstractions that were not
paying for themselves have been removed.

[rriddle]

Any reason this couldn't have been split into multi revisions? e.g. one per dialect?

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

59

///

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

23

Drop newline.

28

nit: Remove the newlines.

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

63

nit: Drop the newline.

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

20

///

mlir/include/mlir/EDSC/Builders.h

517

We should be able to remove these.

[nicolasvasilache]

@rriddle I did not see a simple way to untangle things and once I got things working I did not look back.
For instance, dropping dependencies from EDSC onto LoopOps and AffineOps requires extracting the makeLoopBuilder into a free function.
The only place where it makes sense to put this is in the loop dialect.
There are a bunch of similar cases.
At which point I don't see a reasonable way to split this up.

[nicolasvasilache]

Address review comments.

[nicolasvasilache]

Addressed.

[ftynse]

cmake seems broken

CMake Error at ~/llvm-project/llvm/cmake/modules/AddLLVM.cmake:493 (add_library):
  Cannot find source file:

    Helpers.cpp

  Tried extensions .c .C .c++ .cc .cpp .cxx .cu .m .M .mm .h .hh .h++ .hm
  .hpp .hxx .in .txx
Call Stack (most recent call first):
  ~/llvm-project/llvm/cmake/modules/AddLLVM.cmake:704 (llvm_add_library)
  ~/llvm-project/mlir/lib/EDSC/CMakeLists.txt:8 (add_llvm_library)

[ftynse]

Layering-wise, this makes sense to me. EDSC is a utility library, similar to IR, and should not depend on an ever-growing set of dialects, rather the inverse.

I don't understand why the folder-related part is located under Linalg/, it does not look too specific to it ?

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

28

This looks generally useful, any reason why it's under Linalg/ ?

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

40

Shouldn't this rather be in StandardOps/EDSC/Intrinsics?

[nicolasvasilache]

Address review comments, revive CMake changes.

[nicolasvasilache]

cmake seems broken

The joys of cross-toolchain edit and updates, should be fixed now (at least it runs locally).

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

28

The folder depends on FoldUtils which depends on StandardOps.
Splitting it out of EDSC is necessary, since Linalg is the only user for now I put it here to untangle for now.
Moved it to StandardOps for now but until FoldUtils drops the dependence (if possible?) it can't go at the top level.

[ftynse]

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

28

Let's have a ticket for this.

mlir/docs/EDSC.md

 
 `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 = constant_index(0);
+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

 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(constant_float(llvm::APFloat(7.0f), f32Type)),
-              f13(constant_float(llvm::APFloat(13.0f), f32Type)),
+  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));
   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));

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

+//===- Builders.h - MLIR Declarative Builder Classes ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides intuitive composable interfaces for building structured MLIR
+// snippets in a declarative fashion.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_
+#define MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_
+
+#include "mlir/Dialect/AffineOps/AffineOps.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
+/// *only* way to capture the loop induction variable.
+LoopBuilder makeAffineLoopBuilder(ValueHandle *iv,
+                                  ArrayRef<ValueHandle> lbHandles,
+                                  ArrayRef<ValueHandle> ubHandles,
+                                  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++
+///    AffineLoopNestBuilder({&i, &j, &k}, {lb, lb, lb}, {ub, ub, ub}, {1, 1,
+///    1})(
+///      [&](){
+///        ...
+///      });
+/// ```
+///
+/// ```c++
+///    AffineLoopNestBuilder({&i}, {lb}, {ub}, {1})([&](){
+///      AffineLoopNestBuilder({&j}, {lb}, {ub}, {1})([&](){
+///        AffineLoopNestBuilder({&k}, {lb}, {ub}, {1})([&](){
+///          ...
+///        }),
+///      }),
+///    });
+/// ```
+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);
+
+  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);
+
+} // namespace op
+
+/// Operator overloadings.
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator+(ValueHandle e) {
+  using op::operator+;
+  return static_cast<ValueHandle>(*this) + e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator-(ValueHandle e) {
+  using op::operator-;
+  return static_cast<ValueHandle>(*this) - e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator*(ValueHandle e) {
+  using op::operator*;
+  return static_cast<ValueHandle>(*this) * e;
+}
+template <typename Load, typename Store>
+ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) {
+  using op::operator/;
+  return static_cast<ValueHandle>(*this) / e;
+}
+
+template <typename Load, typename Store>
+OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle 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) {
+  using op::operator-;
+  return Store(*this - e, getBase(), {indices.begin(), indices.end()});
+}
+template <typename Load, typename Store>
+OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle 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) {
+  using op::operator/;
+  return Store(*this / e, getBase(), {indices.begin(), indices.end()});
+}
+
+} // namespace edsc
+} // namespace mlir
+
+#endif // MLIR_DIALECT_AFFINEOPS_EDSC_BUILDERS_H_

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

+//===- Intrinsics.h - MLIR EDSC Intrinsics for AffineOps --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef MLIR_DIALECT_AFFINEOPS_EDSC_INTRINSICS_H_
+#define MLIR_DIALECT_AFFINEOPS_EDSC_INTRINSICS_H_
+
+#include "mlir/Dialect/AffineOps/EDSC/Builders.h"
+#include "mlir/EDSC/Intrinsics.h"
+
+namespace mlir {
+namespace edsc {
+namespace intrinsics {
+
+using affine_apply = ValueBuilder<AffineApplyOp>;
+using affine_if = OperationBuilder<AffineIfOp>;
+using affine_load = ValueBuilder<AffineLoadOp>;
+using affine_min = ValueBuilder<AffineMinOp>;
+using affine_max = ValueBuilder<AffineMaxOp>;
+using affine_store = OperationBuilder<AffineStoreOp>;
+
+/// Provide an index notation around affine_load and affine_store.
+using AffineIndexedValue = TemplatedIndexedValue<affine_load, affine_store>;
+
+} // namespace intrinsics
+} // namespace edsc
+} // namespace mlir
+
+#endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

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

 //===- Builders.h - MLIR Declarative Linalg Builders ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides intuitive composable interfaces for building structured MLIR
 // snippets in a declarative fashion.
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 #define MLIR_DIALECT_LINALG_EDSC_BUILDERS_H_
 
-#include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+// TODO(ntv): Needed for SubViewOp::Range, clean this up.
+#include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
-#include "mlir/IR/AffineExpr.h"
-#include "mlir/IR/Builders.h"
 
 namespace mlir {
+class AffineForOp;
 class BlockArgument;
+class SubViewOp;
+
+namespace loop {
+class ParallelOp;
+} // namespace loop
 
 namespace edsc {
+class AffineLoopNestBuilder;
+class ParallelLoopNestBuilder;
 
 /// 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
Operation *makeGenericLinalgOp(
     ArrayRef<StructuredIndexed> outputs,
     function_ref<void(ArrayRef<BlockArgument>)> regionBuilder =
         defaultRegionBuilder,
     ArrayRef<Value> otherValues = {}, ArrayRef<Attribute> otherAttributes = {});
 
 namespace ops {
 using edsc::StructuredIndexed;
 using edsc::ValueHandle;
-using edsc::intrinsics::linalg_yield;
 
 //===----------------------------------------------------------------------===//
 // EDSC builders for linalg generic operations.
 //===----------------------------------------------------------------------===//
 
 /// Build the body of a region to compute a multiply-accumulate, under the
 /// current ScopedContext, at the current insert point.
 void macRegionBuilder(ArrayRef<BlockArgument> args);

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

 //===- Intrinsics.h - MLIR EDSC Intrinsics for Linalg -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_DIALECT_LINALG_EDSC_INTRINSICS_H_
 #define MLIR_DIALECT_LINALG_EDSC_INTRINSICS_H_
 
-#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
-#include "mlir/EDSC/Builders.h"
+#include "mlir/Dialect/Linalg/EDSC/Builders.h"
 #include "mlir/EDSC/Intrinsics.h"
+#include "mlir/Transforms/FoldUtils.h"
 
 namespace mlir {
 namespace edsc {
+
+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...));
+}
+
 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 linalg_copy = OperationBuilder<linalg::CopyOp>;
 using linalg_fill = OperationBuilder<linalg::FillOp>;
 using linalg_range = ValueBuilder<linalg::RangeOp>;
 using linalg_reshape = ValueBuilder<linalg::ReshapeOp>;
 using linalg_slice = ValueBuilder<linalg::SliceOp>;
 using linalg_yield = OperationBuilder<linalg::YieldOp>;
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_EDSC_INTRINSICS_H_

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

+//===- Builders.h - MLIR Declarative Builder Classes ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides intuitive composable interfaces for building structured MLIR
+// snippets in a declarative fashion.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_LOOPOPS_EDSC_BUILDERS_H_
+#define MLIR_DIALECT_LOOPOPS_EDSC_BUILDERS_H_
+
+#include "mlir/Dialect/LoopOps/LoopOps.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
+/// 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);
+/// Constructs a new loop::ForOp and captures the associated induction
+/// variable. A ValueHandle 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);
+
+/// 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);
+
+  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(ArrayRef<edsc::ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
+                  ArrayRef<ValueHandle> ubs, ArrayRef<ValueHandle> steps);
+  void 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

+//===- Builders.h - MLIR EDSC Builders 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_BUILDERS_H_
+#define MLIR_DIALECT_STANDARDOPS_EDSC_BUILDERS_H_
+
+#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/EDSC/Builders.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/Types.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]; }
+  int64_t step(unsigned idx) { return steps[idx]; }
+  std::tuple<ValueHandle, ValueHandle, 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(steps[i], steps[j]);
+  }
+
+  ArrayRef<ValueHandle> getLbs() { return lbs; }
+  ArrayRef<ValueHandle> getUbs() { return ubs; }
+  ArrayRef<int64_t> getSteps() { return steps; }
+
+protected:
+  SmallVector<ValueHandle, 8> lbs;
+  SmallVector<ValueHandle, 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;
+};
+
+/// 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;
+};
+
+} // 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 {
+
+using std_addf = ValueBuilder<AddFOp>;
+using std_alloc = ValueBuilder<AllocOp>;
+using std_call = OperationBuilder<CallOp>;
+using std_constant_float = ValueBuilder<ConstantFloatOp>;
+using std_constant_index = ValueBuilder<ConstantIndexOp>;
+using std_constant_int = ValueBuilder<ConstantIntOp>;
+using std_dealloc = OperationBuilder<DeallocOp>;
+using std_dim = ValueBuilder<DimOp>;
+using std_muli = ValueBuilder<MulIOp>;
+using std_mulf = ValueBuilder<MulFOp>;
+using std_memref_cast = ValueBuilder<MemRefCastOp>;
+using std_ret = OperationBuilder<ReturnOp>;
+using std_select = ValueBuilder<SelectOp>;
+using std_load = ValueBuilder<LoadOp>;
+using std_store = OperationBuilder<StoreOp>;
+using std_subi = ValueBuilder<SubIOp>;
+using std_tanh = ValueBuilder<TanhOp>;
+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 br(BlockHandle bh, ArrayRef<ValueHandle> 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 br(BlockHandle *bh, ArrayRef<ValueHandle *> captures,
+                   ArrayRef<ValueHandle> 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 cond_br(ValueHandle cond, BlockHandle trueBranch,
+                        ArrayRef<ValueHandle> trueOperands,
+                        BlockHandle falseBranch,
+                        ArrayRef<ValueHandle> 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 cond_br(ValueHandle cond, BlockHandle *trueBranch,
+                        ArrayRef<ValueHandle *> trueCaptures,
+                        ArrayRef<ValueHandle> trueOperands,
+                        BlockHandle *falseBranch,
+                        ArrayRef<ValueHandle *> falseCaptures,
+                        ArrayRef<ValueHandle> falseOperands);
+
+/// Provide an index notation around sdt_load and std_store.
+using StdIndexedValue =
+    TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
+
+} // namespace intrinsics
+} // namespace edsc
+} // namespace mlir
+
+#endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

mlir/include/mlir/EDSC/Builders.h

 //===- Builders.h - MLIR Declarative Builder Classes ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides intuitive composable interfaces for building structured MLIR
 // snippets in a declarative fashion.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EDSC_BUILDERS_H_
 #define MLIR_EDSC_BUILDERS_H_
 
-#include "mlir/Dialect/AffineOps/AffineOps.h"
-#include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
-#include "mlir/Transforms/FoldUtils.h"
+#include "mlir/IR/StandardTypes.h"
+#include "mlir/IR/Types.h"
 
 namespace mlir {
+class OperationFolder;
 
 namespace edsc {
-
-struct index_type {
-  explicit index_type(int64_t v) : v(v) {}
-  explicit operator int64_t() { return v; }
-  int64_t v;
-};
-
 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

 /// A LoopBuilder is a generic NestedBuilder for loop-like MLIR 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).
 /// This is extensible and will evolve in the future as MLIR evolves, hence
 /// the name LoopBuilder (as opposed to say ForBuilder or AffineForBuilder).
 class LoopBuilder : public NestedBuilder {
 public:
-  /// Constructs a new AffineForOp and captures the associated induction
-  /// variable. A ValueHandle pointer is passed as the first argument and is the
-  /// *only* way to capture the loop induction variable.
-  static LoopBuilder makeAffine(ValueHandle *iv,
-                                ArrayRef<ValueHandle> lbHandles,
-                                ArrayRef<ValueHandle> ubHandles, int64_t step);
-  /// Constructs a new loop::ParallelOp and captures the associated induction
-  /// variables. An array of ValueHandle pointers is passed as the first
-  /// argument and is the *only* way to capture loop induction variables.
-  static LoopBuilder makeParallel(ArrayRef<ValueHandle *> ivs,
-                                  ArrayRef<ValueHandle> lbHandles,
-                                  ArrayRef<ValueHandle> ubHandles,
-                                  ArrayRef<ValueHandle> steps);
-  /// Constructs a new loop::ForOp and captures the associated induction
-  /// variable. A ValueHandle pointer is passed as the first argument and is the
-  /// *only* way to capture the loop induction variable.
-  static LoopBuilder makeLoop(ValueHandle *iv, ValueHandle lbHandle,
-                              ValueHandle ubHandle, ValueHandle stepHandle);
   LoopBuilder(const LoopBuilder &) = delete;
   LoopBuilder(LoopBuilder &&) = default;
 
   LoopBuilder &operator=(const LoopBuilder &) = delete;
   LoopBuilder &operator=(LoopBuilder &&) = 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 LoopBuilder.
   void operator()(function_ref<void(void)> fun = nullptr);
 
 private:
   LoopBuilder() = default;
-};
 
-/// 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++
-///    AffineLoopNestBuilder({&i, &j, &k}, {lb, lb, lb}, {ub, ub, ub}, {1, 1,
-///    1})(
-///      [&](){
-///        ...
-///      });
-/// ```
-///
-/// ```c++
-///    AffineLoopNestBuilder({&i}, {lb}, {ub}, {1})([&](){
-///      AffineLoopNestBuilder({&j}, {lb}, {ub}, {1})([&](){
-///        AffineLoopNestBuilder({&k}, {lb}, {ub}, {1})([&](){
-///          ...
-///        }),
-///      }),
-///    });
-/// ```
-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);
-
-  void operator()(function_ref<void(void)> fun = nullptr);
-
-private:
-  SmallVector<LoopBuilder, 4> loops;
-};
-
-/// 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,
+  friend LoopBuilder makeAffineLoopBuilder(ValueHandle *iv,
+                                           ArrayRef<ValueHandle> lbHandles,
+                                           ArrayRef<ValueHandle> ubHandles,
+                                           int64_t step);
+  friend LoopBuilder makeParallelLoopBuilder(ArrayRef<ValueHandle *> ivs,
+                                             ArrayRef<ValueHandle> lbHandles,
+                                             ArrayRef<ValueHandle> ubHandles,
                                              ArrayRef<ValueHandle> 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(ArrayRef<edsc::ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-                  ArrayRef<ValueHandle> ubs, ArrayRef<ValueHandle> steps);
-  void operator()(std::function<void(void)> fun = nullptr);
-
-private:
-  SmallVector<LoopBuilder, 4> loops;
+  friend LoopBuilder makeLoopBuilder(ValueHandle *iv, ValueHandle lbHandle,
+                                     ValueHandle ubHandle,
+                                     ValueHandle stepHandle);
 };
 
 // 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
public:
   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) {}
 
-  /// Builds a ConstantIndexOp of value `cst`. The constant is created at the
-  /// current insertion point.
-  /// This implicit constructor is provided to each build an eager Value for a
-  /// constant at the current insertion point in the IR. An implicit constructor
-  /// allows idiomatic expressions mixing ValueHandle and literals.
-  ValueHandle(index_type cst);
-
   /// 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.
public:
   /// 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);
 
-  /// Special case to build composed AffineApply operations.
-  // TODO: createOrFold when available and move inside of the `create` method.
-  static ValueHandle createComposedAffineApply(AffineMap map,
-                                               ArrayRef<Value> operands);
-
   /// 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
return cast<Op>(
           .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) {
+  if (op->getNumResults() == 1)
     return ValueHandle(op->getResult(0));
-  } else if (op->getNumResults() == 0) {
-    if (auto f = dyn_cast<AffineForOp>(op)) {
-      return ValueHandle(f.getInductionVar());
-    }
-  }
   llvm_unreachable("unsupported operation, use an OperationHandle instead");
 }
 
-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...));
-}
-
-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);
-
-} // namespace op
-
 /// 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
+/// `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) {}
+
+  TemplatedIndexedValue(const TemplatedIndexedValue &rhs) = default;
+
+  TemplatedIndexedValue operator()() { return *this; }
+  /// Returns a new `TemplatedIndexedValue`.
+  TemplatedIndexedValue operator()(ValueHandle index) {
+    TemplatedIndexedValue res(base);
+    res.indices.push_back(index);
+    return res;
+  }
+  template <typename... Args>
+  TemplatedIndexedValue operator()(ValueHandle index, Args... indices) {
+    return TemplatedIndexedValue(base, index).append(indices...);
+  }
+  TemplatedIndexedValue operator()(ArrayRef<ValueHandle> indices) {
+    return TemplatedIndexedValue(base, 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()});
+  }
+
+  /// Emits a `load` when converting to a Value.
+  Value operator*(void) const {
+    return Load(getBase(), {indices.begin(), indices.end()}).getValue();
+  }
+
+  ValueHandle getBase() const { return base; }
+
+  /// Operator overloadings.
+  ValueHandle operator+(ValueHandle e);
+  ValueHandle operator-(ValueHandle e);
+  ValueHandle operator*(ValueHandle e);
+  ValueHandle operator/(ValueHandle e);
+  OperationHandle operator+=(ValueHandle e);
+  OperationHandle operator-=(ValueHandle e);
+  OperationHandle operator*=(ValueHandle e);
+  OperationHandle 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);
+  }
+  ValueHandle operator/(TemplatedIndexedValue e) {
+    return *this / static_cast<ValueHandle>(e);
+  }
+  OperationHandle operator+=(TemplatedIndexedValue e) {
+    return this->operator+=(static_cast<ValueHandle>(e));
+  }
+  OperationHandle operator-=(TemplatedIndexedValue e) {
+    return this->operator-=(static_cast<ValueHandle>(e));
+  }
+  OperationHandle operator*=(TemplatedIndexedValue e) {
+    return this->operator*=(static_cast<ValueHandle>(e));
+  }
+  OperationHandle operator/=(TemplatedIndexedValue e) {
+    return this->operator/=(static_cast<ValueHandle>(e));
+  }
+
+private:
+  TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices)
+      : base(base), 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));
+    append(indices...);
+    return *this;
+  }
+  ValueHandle base;
+  SmallVector<ValueHandle, 8> indices;
+};
+
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_EDSC_BUILDERS_H_

mlir/include/mlir/EDSC/Helpers.h

-//===- Helpers.h - MLIR Declarative Helper Functionality --------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Provides helper classes and syntactic sugar for declarative builders.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_EDSC_HELPERS_H_
-#define MLIR_EDSC_HELPERS_H_
-
-#include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
-
-namespace mlir {
-namespace edsc {
-
-// A TemplatedIndexedValue brings an index notation over the template Load and
-// Store parameters.
-template <typename Load, typename Store> class TemplatedIndexedValue;
-
-// By default, edsc::IndexedValue provides an index notation around the affine
-// load and stores. edsc::StdIndexedValue provides the standard load/store
-// counterpart.
-using IndexedValue =
-    TemplatedIndexedValue<intrinsics::affine_load, intrinsics::affine_store>;
-using StdIndexedValue =
-    TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
-
-// Base class for MemRefView and VectorView.
-class View {
-public:
-  unsigned rank() const { return lbs.size(); }
-  ValueHandle lb(unsigned idx) { return lbs[idx]; }
-  ValueHandle ub(unsigned idx) { return ubs[idx]; }
-  int64_t step(unsigned idx) { return steps[idx]; }
-  std::tuple<ValueHandle, ValueHandle, 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(steps[i], steps[j]);
-  }
-
-  ArrayRef<ValueHandle> getLbs() { return lbs; }
-  ArrayRef<ValueHandle> getUbs() { return ubs; }
-  ArrayRef<int64_t> getSteps() { return steps; }
-
-protected:
-  SmallVector<ValueHandle, 8> lbs;
-  SmallVector<ValueHandle, 8> ubs;
-  SmallVector<int64_t, 8> steps;
-};
-
-/// A MemRefView 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 MemRefView : public View {
-public:
-  explicit MemRefView(Value v);
-  MemRefView(const MemRefView &) = default;
-  MemRefView &operator=(const MemRefView &) = default;
-
-  unsigned fastestVarying() const { return rank() - 1; }
-
-private:
-  friend IndexedValue;
-  ValueHandle base;
-};
-
-/// A VectorView represents the information required to step through a
-/// Vector accessing each scalar element at a time. It is the counterpart of
-/// a MemRefView but for vectors. This exists purely for boilerplate avoidance.
-class VectorView : public View {
-public:
-  explicit VectorView(Value v);
-  VectorView(const VectorView &) = default;
-  VectorView &operator=(const VectorView &) = default;
-
-private:
-  friend IndexedValue;
-  ValueHandle base;
-};
-
-/// A TemplatedIndexedValue brings an index notation over the template Load and
-/// Store parameters. This helper class is an abstraction purely for sugaring
-/// purposes and allows writing compact expressions such as:
-///
-/// ```mlir
-///    // `IndexedValue` provided by default in the mlir::edsc namespace.
-///    using IndexedValue =
-///      TemplatedIndexedValue<intrinsics::load, intrinsics::store>;
-///    IndexedValue A(...), B(...), C(...);
-///    For(ivs, zeros, shapeA, ones, {
-///      C(ivs) = A(ivs) + B(ivs)
-///    });
-/// ```
-///
-/// Assigning to an IndexedValue emits an actual `Store` operation, while
-/// converting an IndexedValue to a ValueHandle 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) {}
-
-  TemplatedIndexedValue(const TemplatedIndexedValue &rhs) = default;
-
-  TemplatedIndexedValue operator()() { return *this; }
-  /// Returns a new `TemplatedIndexedValue`.
-  TemplatedIndexedValue operator()(ValueHandle index) {
-    TemplatedIndexedValue res(base);
-    res.indices.push_back(index);
-    return res;
-  }
-  template <typename... Args>
-  TemplatedIndexedValue operator()(ValueHandle index, Args... indices) {
-    return TemplatedIndexedValue(base, index).append(indices...);
-  }
-  TemplatedIndexedValue operator()(ArrayRef<ValueHandle> indices) {
-    return TemplatedIndexedValue(base, indices);
-  }
-  TemplatedIndexedValue operator()(ArrayRef<IndexHandle> indices) {
-    return TemplatedIndexedValue(
-        base, ArrayRef<ValueHandle>(indices.begin(), indices.end()));
-  }
-
-  /// Emits a `store`.
-  // NOLINTNEXTLINE: unconventional-assign-operator
-  OperationHandle operator=(const TemplatedIndexedValue &rhs) {
-    ValueHandle rrhs(rhs);
-    return Store(rrhs, getBase(), {indices.begin(), indices.end()});
-  }
-  // NOLINTNEXTLINE: unconventional-assign-operator
-  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()});
-  }
-
-  /// Emits a `load` when converting to a Value.
-  Value operator*(void) const {
-    return Load(getBase(), {indices.begin(), indices.end()}).getValue();
-  }
-
-  ValueHandle getBase() const { return base; }
-
-  /// Operator overloadings.
-  ValueHandle operator+(ValueHandle e);
-  ValueHandle operator-(ValueHandle e);
-  ValueHandle operator*(ValueHandle e);
-  ValueHandle operator/(ValueHandle e);
-  OperationHandle operator+=(ValueHandle e);
-  OperationHandle operator-=(ValueHandle e);
-  OperationHandle operator*=(ValueHandle e);
-  OperationHandle 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);
-  }
-  ValueHandle operator/(TemplatedIndexedValue e) {
-    return *this / static_cast<ValueHandle>(e);
-  }
-  OperationHandle operator+=(TemplatedIndexedValue e) {
-    return this->operator+=(static_cast<ValueHandle>(e));
-  }
-  OperationHandle operator-=(TemplatedIndexedValue e) {
-    return this->operator-=(static_cast<ValueHandle>(e));
-  }
-  OperationHandle operator*=(TemplatedIndexedValue e) {
-    return this->operator*=(static_cast<ValueHandle>(e));
-  }
-  OperationHandle operator/=(TemplatedIndexedValue e) {
-    return this->operator/=(static_cast<ValueHandle>(e));
-  }
-
-private:
-  TemplatedIndexedValue(ValueHandle base, ArrayRef<ValueHandle> indices)
-      : base(base), 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));
-    append(indices...);
-    return *this;
-  }
-  ValueHandle base;
-  SmallVector<ValueHandle, 8> indices;
-};
-
-/// Operator overloadings.
-template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator+(ValueHandle e) {
-  using op::operator+;
-  return static_cast<ValueHandle>(*this) + e;
-}
-template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator-(ValueHandle e) {
-  using op::operator-;
-  return static_cast<ValueHandle>(*this) - e;
-}
-template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator*(ValueHandle e) {
-  using op::operator*;
-  return static_cast<ValueHandle>(*this) * e;
-}
-template <typename Load, typename Store>
-ValueHandle TemplatedIndexedValue<Load, Store>::operator/(ValueHandle e) {
-  using op::operator/;
-  return static_cast<ValueHandle>(*this) / e;
-}
-
-template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator+=(ValueHandle 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) {
-  using op::operator-;
-  return Store(*this - e, getBase(), {indices.begin(), indices.end()});
-}
-template <typename Load, typename Store>
-OperationHandle TemplatedIndexedValue<Load, Store>::operator*=(ValueHandle 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) {
-  using op::operator/;
-  return Store(*this / e, getBase(), {indices.begin(), indices.end()});
-}
-
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_EDSC_HELPERS_H_

mlir/include/mlir/EDSC/Intrinsics.h

 //===- Intrinsics.h - MLIR Operations for Declarative Builders ---*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides intuitive composable intrinsics for building snippets of MLIR
-// declaratively
+// declaratively.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EDSC_INTRINSICS_H_
 #define MLIR_EDSC_INTRINSICS_H_
 
 #include "mlir/EDSC/Builders.h"
+#include "mlir/IR/StandardTypes.h"
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
 
 class MemRefType;
 class Type;
 
 namespace edsc {
 
-/// An IndexHandle is a simple wrapper around a ValueHandle.
-/// IndexHandles are ubiquitous enough to justify a new type to allow simple
-/// declarations without boilerplate such as:
-///
-/// ```c++
-///    IndexHandle i, j, k;
-/// ```
-struct IndexHandle : public ValueHandle {
-  explicit IndexHandle()
-      : ValueHandle(ScopedContext::getBuilder().getIndexType()) {}
-  explicit IndexHandle(index_type v) : ValueHandle(v) {}
-  explicit IndexHandle(Value v) : ValueHandle(v) {
-    assert(v.getType() == ScopedContext::getBuilder().getIndexType() &&
-           "Expected index type");
-  }
-  explicit IndexHandle(ValueHandle v) : ValueHandle(v) {
-    assert(v.getType() == ScopedContext::getBuilder().getIndexType() &&
-           "Expected index type");
-  }
-  IndexHandle &operator=(const ValueHandle &v) {
-    assert(v.getType() == ScopedContext::getBuilder().getIndexType() &&
-           "Expected index type");
-    /// Creating a new IndexHandle(v) and then std::swap rightly complains the
-    /// binding has already occurred and that we should use another name.
-    this->t = v.getType();
-    this->v = v.getValue();
-    return *this;
-  }
-};
-
-inline SmallVector<IndexHandle, 8> makeIndexHandles(unsigned rank) {
-  return SmallVector<IndexHandle, 8>(rank);
-}
-
-/// Entry point to build multiple ValueHandle* from a mutable list `ivs` of T.
-template <typename T>
+/// Entry point to build multiple ValueHandle* from a mutable list `ivs`.
 inline SmallVector<ValueHandle *, 8>
-makeHandlePointers(MutableArrayRef<T> ivs) {
+makeHandlePointers(MutableArrayRef<ValueHandle> ivs) {
   SmallVector<ValueHandle *, 8> pivs;
   pivs.reserve(ivs.size());
-  for (auto &iv : ivs) {
+  for (auto &iv : ivs)
     pivs.push_back(&iv);
-  }
   return pivs;
 }
 
-/// Returns a vector of the underlying Value from `ivs`.
-inline SmallVector<Value, 8> extractValues(ArrayRef<IndexHandle> ivs) {
-  SmallVector<Value, 8> vals;
-  vals.reserve(ivs.size());
-  for (auto &iv : ivs) {
-    vals.push_back(iv.getValue());
-  }
-  return vals;
-}
-
 /// 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());
   }
-  ValueHandleArray(ArrayRef<IndexHandle> vals) {
-    values.append(vals.begin(), vals.end());
-  }
-  ValueHandleArray(ArrayRef<index_type> vals) {
-    SmallVector<IndexHandle, 8> tmp(vals.begin(), vals.end());
-    values.append(tmp.begin(), tmp.end());
-  }
   operator ArrayRef<Value>() { return values; }
 
 private:
   ValueHandleArray() = default;
   SmallVector<Value, 8> values;
 };
 
 template <typename T> inline T unpack(T value) { return value; }
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)...)) {}
 
-  /// 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)...)) {}
-
   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)
template <typename Op> struct OperationBuilder : public OperationHandle {
   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() : OperationHandle(OperationHandle::create<Op>()) {}
 };
 
-using addf = ValueBuilder<AddFOp>;
-using affine_apply = ValueBuilder<AffineApplyOp>;
-using affine_if = OperationBuilder<AffineIfOp>;
-using affine_load = ValueBuilder<AffineLoadOp>;
-using affine_min = ValueBuilder<AffineMinOp>;
-using affine_max = ValueBuilder<AffineMaxOp>;
-using affine_store = OperationBuilder<AffineStoreOp>;
-using alloc = ValueBuilder<AllocOp>;
-using call = OperationBuilder<mlir::CallOp>;
-using constant_float = ValueBuilder<ConstantFloatOp>;
-using constant_index = ValueBuilder<ConstantIndexOp>;
-using constant_int = ValueBuilder<ConstantIntOp>;
-using dealloc = OperationBuilder<DeallocOp>;
-using dim = ValueBuilder<DimOp>;
-using muli = ValueBuilder<MulIOp>;
-using mulf = ValueBuilder<MulFOp>;
-using memref_cast = ValueBuilder<MemRefCastOp>;
-using ret = OperationBuilder<ReturnOp>;
-using select = ValueBuilder<SelectOp>;
-using std_load = ValueBuilder<LoadOp>;
-using std_store = OperationBuilder<StoreOp>;
-using subi = ValueBuilder<SubIOp>;
-using tanh = ValueBuilder<TanhOp>;
-using view = ValueBuilder<ViewOp>;
-using zero_extendi = ValueBuilder<ZeroExtendIOp>;
-using 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 br(BlockHandle bh, ArrayRef<ValueHandle> 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 br(BlockHandle *bh, ArrayRef<ValueHandle *> captures,
-                   ArrayRef<ValueHandle> 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 cond_br(ValueHandle cond, BlockHandle trueBranch,
-                        ArrayRef<ValueHandle> trueOperands,
-                        BlockHandle falseBranch,
-                        ArrayRef<ValueHandle> 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 cond_br(ValueHandle cond, BlockHandle *trueBranch,
-                        ArrayRef<ValueHandle *> trueCaptures,
-                        ArrayRef<ValueHandle> trueOperands,
-                        BlockHandle *falseBranch,
-                        ArrayRef<ValueHandle *> falseCaptures,
-                        ArrayRef<ValueHandle> falseOperands);
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_EDSC_INTRINSICS_H_

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 #include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
-#include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/PatternMatch.h"

 #include "llvm/Support/ErrorHandling.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::LLVM;
 using namespace mlir::linalg;
 
-using add = ValueBuilder<mlir::LLVM::AddOp>;
-using addi = ValueBuilder<mlir::AddIOp>;
-using bitcast = ValueBuilder<mlir::LLVM::BitcastOp>;
-using cmpi = ValueBuilder<mlir::CmpIOp>;
-using constant = ValueBuilder<mlir::LLVM::ConstantOp>;
-using extractvalue = ValueBuilder<mlir::LLVM::ExtractValueOp>;
-using gep = ValueBuilder<mlir::LLVM::GEPOp>;
-using insertvalue = ValueBuilder<mlir::LLVM::InsertValueOp>;
-using llvm_call = OperationBuilder<mlir::LLVM::CallOp>;
+using llvm_add = ValueBuilder<LLVM::AddOp>;
+using llvm_bitcast = ValueBuilder<LLVM::BitcastOp>;
+using llvm_constant = ValueBuilder<LLVM::ConstantOp>;
+using llvm_extractvalue = ValueBuilder<LLVM::ExtractValueOp>;
+using llvm_gep = ValueBuilder<LLVM::GEPOp>;
+using llvm_insertvalue = ValueBuilder<LLVM::InsertValueOp>;
+using llvm_call = OperationBuilder<LLVM::CallOp>;
 using llvm_icmp = ValueBuilder<LLVM::ICmpOp>;
 using llvm_load = ValueBuilder<LLVM::LoadOp>;
 using llvm_store = OperationBuilder<LLVM::StoreOp>;
 using llvm_select = ValueBuilder<LLVM::SelectOp>;
-using mul = ValueBuilder<mlir::LLVM::MulOp>;
-using ptrtoint = ValueBuilder<mlir::LLVM::PtrToIntOp>;
-using sub = ValueBuilder<mlir::LLVM::SubOp>;
-using llvm_undef = ValueBuilder<mlir::LLVM::UndefOp>;
-using urem = ValueBuilder<mlir::LLVM::URemOp>;
+using llvm_mul = ValueBuilder<LLVM::MulOp>;
+using llvm_ptrtoint = ValueBuilder<LLVM::PtrToIntOp>;
+using llvm_sub = ValueBuilder<LLVM::SubOp>;
+using llvm_undef = ValueBuilder<LLVM::UndefOp>;
+using llvm_urem = ValueBuilder<LLVM::URemOp>;
 using llvm_alloca = ValueBuilder<LLVM::AllocaOp>;
 using llvm_return = OperationBuilder<LLVM::ReturnOp>;
 
 template <typename T>
 static LLVMType getPtrToElementType(T containerType,
                                     LLVMTypeConverter &lowering) {
   return lowering.convertType(containerType.getElementType())
       .template cast<LLVMType>()
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     auto rangeDescriptorTy =
         convertLinalgType(rangeOp.getResult().getType(), lowering);
 
     edsc::ScopedContext context(rewriter, op->getLoc());
 
     // Fill in an aggregate value of the descriptor.
     RangeOpOperandAdaptor adaptor(operands);
     Value desc = llvm_undef(rangeDescriptorTy);
-    desc = insertvalue(desc, adaptor.min(), rewriter.getI64ArrayAttr(0));
-    desc = insertvalue(desc, adaptor.max(), rewriter.getI64ArrayAttr(1));
-    desc = insertvalue(desc, adaptor.step(), rewriter.getI64ArrayAttr(2));
+    desc = llvm_insertvalue(desc, adaptor.min(), rewriter.getI64ArrayAttr(0));
+    desc = llvm_insertvalue(desc, adaptor.max(), rewriter.getI64ArrayAttr(1));
+    desc = llvm_insertvalue(desc, adaptor.step(), rewriter.getI64ArrayAttr(2));
     rewriter.replaceOp(op, desc);
     return matchSuccess();
   }
 };
 
 // ReshapeOp creates a new view descriptor of the proper rank.
 // For now, the only conversion supported is for target MemRef with static sizes
 // and strides.
matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     };
 
     // Compute base offset.
     Value baseOffset = baseDesc.offset();
     for (int i = 0, e = memRefType.getRank(); i < e; ++i) {
       Value indexing = adaptor.indexings()[i];
       Value min = indexing;
       if (sliceOp.indexing(i).getType().isa<RangeType>())
-        min = extractvalue(int64Ty, indexing, pos(0));
-      baseOffset = add(baseOffset, mul(min, strides[i]));
+        min = llvm_extractvalue(int64Ty, indexing, pos(0));
+      baseOffset = llvm_add(baseOffset, llvm_mul(min, strides[i]));
     }
 
     // Insert the base and aligned pointers.
     desc.setAllocatedPtr(baseDesc.allocatedPtr());
     desc.setAlignedPtr(baseDesc.alignedPtr());
 
     // Insert base offset.
     desc.setOffset(baseOffset);
 
     // Corner case, no sizes or strides: early return the descriptor.
     if (sliceOp.getShapedType().getRank() == 0)
       return rewriter.replaceOp(op, {desc}), matchSuccess();
 
-    Value zero =
-        constant(int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
+    Value zero = llvm_constant(
+        int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
     // Compute and insert view sizes (max - min along the range) and strides.
     // Skip the non-range operands as they will be projected away from the view.
     int numNewDims = 0;
     for (auto en : llvm::enumerate(sliceOp.indexings())) {
       Value indexing = en.value();
       if (indexing.getType().isa<RangeType>()) {
         int rank = en.index();
         Value rangeDescriptor = adaptor.indexings()[rank];
-        Value min = extractvalue(int64Ty, rangeDescriptor, pos(0));
-        Value max = extractvalue(int64Ty, rangeDescriptor, pos(1));
-        Value step = extractvalue(int64Ty, rangeDescriptor, pos(2));
+        Value min = llvm_extractvalue(int64Ty, rangeDescriptor, pos(0));
+        Value max = llvm_extractvalue(int64Ty, rangeDescriptor, pos(1));
+        Value step = llvm_extractvalue(int64Ty, rangeDescriptor, pos(2));
         Value baseSize = baseDesc.size(rank);
 
         // Bound upper by base view upper bound.
         max = llvm_select(llvm_icmp(ICmpPredicate::slt, max, baseSize), max,
                           baseSize);
-        Value size = sub(max, min);
+        Value size = llvm_sub(max, min);
         // Bound lower by zero.
         size =
             llvm_select(llvm_icmp(ICmpPredicate::slt, size, zero), zero, size);
-        Value stride = mul(strides[rank], step);
+        Value stride = llvm_mul(strides[rank], step);
         desc.setSize(numNewDims, size);
         desc.setStride(numNewDims, stride);
         ++numNewDims;
       }
     }
 
     rewriter.replaceOp(op, {desc});
     return matchSuccess();
PatternMatchResult matchAndRewrite(LinalgOp op,
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
         op, libraryCallName.getValue(), ArrayRef<Type>{}, op.getOperands());
     return this->matchSuccess();
   }
 };
 
 /// Conversion pattern specialization for CopyOp. This kicks in when both input
 /// and output permutations are left unspecified or are the identity.
-template <>
-class LinalgOpConversion<CopyOp> : public OpRewritePattern<CopyOp> {
+template <> class LinalgOpConversion<CopyOp> : public OpRewritePattern<CopyOp> {
 public:
   using OpRewritePattern<CopyOp>::OpRewritePattern;
 
   PatternMatchResult matchAndRewrite(CopyOp op,
                                      PatternRewriter &rewriter) const override {
     auto inputPerm = op.inputPermutation();
     if (inputPerm.hasValue() && !inputPerm->isIdentity())
       return matchFailure();

mlir/lib/Conversion/VectorToLoops/ConvertVectorToLoops.cpp

 //===- VectorToLoops.cpp - Conversion from Vector to mix of Loops and Std -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements target-dependent lowering of vector transfer operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h"
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/VectorOps/VectorOps.h"
-#include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Helpers.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 `vectorView` are swapped so that the invocation of
+/// `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<edsc::ValueHandle *> *pivs,
-                         edsc::VectorView *vectorView) {
+                         SmallVectorImpl<ValueHandle *> *pivs,
+                         VectorBoundsCapture *vectorBoundsCapture) {
   // 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]);
-    vectorView->swapRanges(pivs->size() - 1, coalescedIdx);
+    vectorBoundsCapture->swapRanges(pivs->size() - 1, coalescedIdx);
   }
 }
 
 /// Emits remote memory accesses that are clipped to the boundaries of the
 /// MemRef.
 template <typename TransferOpTy>
-static SmallVector<edsc::ValueHandle, 8> clip(TransferOpTy transfer,
-                                              edsc::MemRefView &view,
-                                              ArrayRef<edsc::IndexHandle> ivs) {
+static SmallVector<ValueHandle, 8> clip(TransferOpTy transfer,
+                                        MemRefBoundsCapture &bounds,
+                                        ArrayRef<ValueHandle> ivs) {
   using namespace mlir::edsc;
-  using namespace edsc::op;
-  using edsc::intrinsics::select;
-
-  IndexHandle zero(index_type(0)), one(index_type(1));
-  SmallVector<edsc::ValueHandle, 8> memRefAccess(transfer.indices());
-  SmallVector<edsc::ValueHandle, 8> clippedScalarAccessExprs(
-      memRefAccess.size(), edsc::IndexHandle());
 
+  ValueHandle zero(std_constant_index(0)), one(std_constant_index(1));
+  SmallVector<ValueHandle, 8> memRefAccess(transfer.indices());
+  auto clippedScalarAccessExprs =
+      ValueHandle::makeIndexHandles(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)) {
       auto expr = en.value();
       auto dim = expr.template dyn_cast<AffineDimExpr>();
       // Sanity check.
       assert(
           (dim || expr.template cast<AffineConstantExpr>().getValue() == 0) &&
           "Expected dim or 0 in permutationMap");
       if (dim && memRefDim == dim.getPosition()) {
         loopIndex = en.index();
         break;
       }
     }
 
     // We cannot distinguish atm between unrolled dimensions that implement
     // the "always full" tile abstraction and need clipping from the other
     // ones. So we conservatively clip everything.
-    auto N = view.ub(memRefDim);
+    using namespace edsc::op;
+    auto N = bounds.ub(memRefDim);
     auto i = memRefAccess[memRefDim];
     if (loopIndex < 0) {
       auto N_minus_1 = N - one;
-      auto select_1 = select(i < N, i, N_minus_1);
-      clippedScalarAccessExprs[memRefDim] = select(i < zero, zero, select_1);
+      auto select_1 = std_select(i < N, i, N_minus_1);
+      clippedScalarAccessExprs[memRefDim] =
+          std_select(i < zero, zero, select_1);
     } else {
       auto ii = ivs[loopIndex];
       auto i_plus_ii = i + ii;
       auto N_minus_1 = N - one;
-      auto select_1 = select(i_plus_ii < N, i_plus_ii, N_minus_1);
+      auto select_1 = std_select(i_plus_ii < N, i_plus_ii, N_minus_1);
       clippedScalarAccessExprs[memRefDim] =
-          select(i_plus_ii < zero, zero, select_1);
+          std_select(i_plus_ii < zero, zero, select_1);
     }
   }
 
   return clippedScalarAccessExprs;
 }
 
 namespace {
 

 ///    }
 /// ```
 ///
 /// In the current state, only a clipping transfer is implemented by `clip`,
 /// which creates individual indexing expressions of the form:
 ///
 /// ```mlir-dsc
 ///    auto condMax = i + ii < N;
-///    auto max = select(condMax, i + ii, N - one)
+///    auto max = std_select(condMax, i + ii, N - one)
 ///    auto cond = i + ii < zero;
-///    select(cond, zero, max);
+///    std_select(cond, zero, max);
 /// ```
 ///
 /// In the future, clipping should not be the only way and instead we should
 /// load vectors + mask them. Similarly on the write side, load/mask/store for
 /// implementing RMW behavior.
 ///
 /// Lowers TransferOp into a combination of:
 ///   1. local memory allocation;

 ///
 /// TODO(ntv): implement alternatives to clipping.
 /// TODO(ntv): support non-data-parallel operations.
 
 /// Performs the rewrite.
 template <>
 PatternMatchResult VectorTransferRewriter<TransferReadOp>::matchAndRewrite(
     Operation *op, PatternRewriter &rewriter) const {
-  using namespace mlir::edsc;
   using namespace mlir::edsc::op;
-  using namespace mlir::edsc::intrinsics;
-  using IndexedValue =
-      TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
 
   TransferReadOp transfer = cast<TransferReadOp>(op);
 
   // 1. Setup all the captures.
   ScopedContext scope(rewriter, transfer.getLoc());
-  IndexedValue remote(transfer.memref());
-  MemRefView view(transfer.memref());
-  VectorView vectorView(transfer.vector());
-  SmallVector<IndexHandle, 8> ivs = makeIndexHandles(vectorView.rank());
+  StdIndexedValue remote(transfer.memref());
+  MemRefBoundsCapture memRefBoundsCapture(transfer.memref());
+  VectorBoundsCapture vectorBoundsCapture(transfer.vector());
+  auto ivs = ValueHandle::makeIndexHandles(vectorBoundsCapture.rank());
   SmallVector<ValueHandle *, 8> pivs =
-      makeHandlePointers(MutableArrayRef<IndexHandle>(ivs));
-  coalesceCopy(transfer, &pivs, &vectorView);
+      makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
+  coalesceCopy(transfer, &pivs, &vectorBoundsCapture);
 
-  auto lbs = vectorView.getLbs();
-  auto ubs = vectorView.getUbs();
+  auto lbs = vectorBoundsCapture.getLbs();
+  auto ubs = vectorBoundsCapture.getUbs();
   SmallVector<ValueHandle, 8> steps;
-  steps.reserve(vectorView.getSteps().size());
-  for (auto step : vectorView.getSteps())
-    steps.push_back(constant_index(step));
+  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 = alloc(tmpMemRefType(transfer));
-  IndexedValue local(tmp);
+  ValueHandle tmp = std_alloc(tmpMemRefType(transfer));
+  StdIndexedValue local(tmp);
   ValueHandle vec = vector_type_cast(tmp);
   LoopNestBuilder(pivs, lbs, ubs, steps)([&] {
     // Computes clippedScalarAccessExprs in the loop nest scope (ivs exist).
-    local(ivs) = remote(clip(transfer, view, ivs));
+    local(ivs) = remote(clip(transfer, memRefBoundsCapture, ivs));
   });
   ValueHandle vectorValue = std_load(vec);
-  (dealloc(tmp)); // vexing parse
+  (std_dealloc(tmp)); // vexing parse
 
   // 3. Propagate.
   rewriter.replaceOp(op, vectorValue.getValue());
   return matchSuccess();
 }
 
 /// Lowers TransferWriteOp into a combination of:
 ///   1. local memory allocation;

 /// See `Important notes about clipping and full-tiles only abstraction` in the
 /// description of `readClipped` above.
 ///
 /// TODO(ntv): implement alternatives to clipping.
 /// TODO(ntv): support non-data-parallel operations.
 template <>
 PatternMatchResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(
     Operation *op, PatternRewriter &rewriter) const {
-  using namespace mlir::edsc;
-  using namespace mlir::edsc::op;
-  using namespace mlir::edsc::intrinsics;
-  using IndexedValue =
-      TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
+  using namespace edsc::op;
 
   TransferWriteOp transfer = cast<TransferWriteOp>(op);
 
   // 1. Setup all the captures.
   ScopedContext scope(rewriter, transfer.getLoc());
-  IndexedValue remote(transfer.memref());
-  MemRefView view(transfer.memref());
+  StdIndexedValue remote(transfer.memref());
+  MemRefBoundsCapture memRefBoundsCapture(transfer.memref());
   ValueHandle vectorValue(transfer.vector());
-  VectorView vectorView(transfer.vector());
-  SmallVector<IndexHandle, 8> ivs = makeIndexHandles(vectorView.rank());
+  VectorBoundsCapture vectorBoundsCapture(transfer.vector());
+  auto ivs = ValueHandle::makeIndexHandles(vectorBoundsCapture.rank());
   SmallVector<ValueHandle *, 8> pivs =
-      makeHandlePointers(MutableArrayRef<IndexHandle>(ivs));
-  coalesceCopy(transfer, &pivs, &vectorView);
+      makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
+  coalesceCopy(transfer, &pivs, &vectorBoundsCapture);
 
-  auto lbs = vectorView.getLbs();
-  auto ubs = vectorView.getUbs();
+  auto lbs = vectorBoundsCapture.getLbs();
+  auto ubs = vectorBoundsCapture.getUbs();
   SmallVector<ValueHandle, 8> steps;
-  steps.reserve(vectorView.getSteps().size());
-  for (auto step : vectorView.getSteps())
-    steps.push_back(constant_index(step));
+  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 = alloc(tmpMemRefType(transfer));
-  IndexedValue local(tmp);
+  ValueHandle tmp = std_alloc(tmpMemRefType(transfer));
+  StdIndexedValue local(tmp);
   ValueHandle vec = vector_type_cast(tmp);
   std_store(vectorValue, vec);
   LoopNestBuilder(pivs, lbs, ubs, steps)([&] {
     // Computes clippedScalarAccessExprs in the loop nest scope (ivs exist).
-    remote(clip(transfer, view, ivs)) = local(ivs);
+    remote(clip(transfer, memRefBoundsCapture, ivs)) = local(ivs);
   });
-  (dealloc(tmp)); // vexing parse...
+  (std_dealloc(tmp)); // vexing parse...
 
   rewriter.eraseOp(op);
   return matchSuccess();
 }
 
 } // namespace
 
 void mlir::populateVectorToAffineLoopsConversionPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns) {
   patterns.insert<VectorTransferRewriter<vector::TransferReadOp>,
                   VectorTransferRewriter<vector::TransferWriteOp>>(context);
 }

mlir/lib/Dialect/AffineOps/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/AffineOps/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) {
+  if (lbs.size() != 1 || ubs.size() != 1)
+    return Optional<ValueHandle>();
+
+  auto *lbDef = lbs.front().getValue().getDefiningOp();
+  auto *ubDef = ubs.front().getValue().getDefiningOp();
+  if (!lbDef || !ubDef)
+    return Optional<ValueHandle>();
+
+  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());
+}
+
+LoopBuilder mlir::edsc::makeAffineLoopBuilder(ValueHandle *iv,
+                                              ArrayRef<ValueHandle> lbHandles,
+                                              ArrayRef<ValueHandle> ubHandles,
+                                              int64_t step) {
+  mlir::edsc::LoopBuilder result;
+  if (auto staticFor = emitStaticFor(lbHandles, ubHandles, step)) {
+    *iv = staticFor.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,
+                              b.getMultiDimIdentityMap(lbs.size()), ubs,
+                              b.getMultiDimIdentityMap(ubs.size()), step)
+            .getInductionVar());
+  }
+  auto *body = getForInductionVarOwner(iv->getValue()).getBody();
+  result.enter(body, /*prev=*/1);
+  return result;
+}
+
+mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
+    ValueHandle *iv, ArrayRef<ValueHandle> lbs, ArrayRef<ValueHandle> 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) {
+  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),
+                                             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,
+    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);
+  std::tie(d1, v1) =
+      categorizeValueByAffineType(context, rhs.getValue(), numDims, numSymbols);
+  SmallVector<Value, 2> operands;
+  if (v0) {
+    operands.push_back(v0);
+  }
+  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));
+}
+
+template <typename IOp, typename FOp>
+static ValueHandle createBinaryHandle(
+    ValueHandle lhs, ValueHandle rhs,
+    function_ref<AffineExpr(AffineExpr, AffineExpr)> affCombiner) {
+  auto thisType = lhs.getValue().getType();
+  auto thatType = rhs.getValue().getType();
+  assert(thisType == thatType && "cannot mix types in operators");
+  (void)thisType;
+  (void)thatType;
+  if (thisType.isIndex()) {
+    return createBinaryIndexHandle(lhs, rhs, affCombiner);
+  } else if (thisType.isa<IntegerType>()) {
+    return createBinaryHandle<IOp>(lhs, rhs);
+  } else if (thisType.isa<FloatType>()) {
+    return createBinaryHandle<FOp>(lhs, rhs);
+  } else if (thisType.isa<VectorType>() || thisType.isa<TensorType>()) {
+    auto aggregateType = thisType.cast<ShapedType>();
+    if (aggregateType.getElementType().isa<IntegerType>())
+      return createBinaryHandle<IOp>(lhs, rhs);
+    else if (aggregateType.getElementType().isa<FloatType>())
+      return createBinaryHandle<FOp>(lhs, rhs);
+  }
+  llvm_unreachable("failed to create a ValueHandle");
+}
+
+ValueHandle mlir::edsc::op::operator+(ValueHandle lhs, ValueHandle rhs) {
+  return createBinaryHandle<AddIOp, AddFOp>(
+      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 + d1; });
+}
+
+ValueHandle mlir::edsc::op::operator-(ValueHandle lhs, ValueHandle rhs) {
+  return createBinaryHandle<SubIOp, SubFOp>(
+      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 - d1; });
+}
+
+ValueHandle mlir::edsc::op::operator*(ValueHandle lhs, ValueHandle rhs) {
+  return createBinaryHandle<MulIOp, MulFOp>(
+      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 * d1; });
+}
+
+ValueHandle mlir::edsc::op::operator/(ValueHandle lhs, ValueHandle 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) {
+  return createBinaryHandle<SignedRemIOp, RemFOp>(
+      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 % d1; });
+}
+
+ValueHandle mlir::edsc::op::floorDiv(ValueHandle lhs, ValueHandle rhs) {
+  return createBinaryIndexHandle(
+      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0.floorDiv(d1); });
+}
+
+ValueHandle mlir::edsc::op::ceilDiv(ValueHandle lhs, ValueHandle 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) {
+  assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
+  assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
+  return lhs * rhs;
+}
+
+ValueHandle mlir::edsc::op::operator||(ValueHandle lhs, ValueHandle rhs) {
+  return !(!lhs && !rhs);
+}
+
+static ValueHandle createIComparisonExpr(CmpIPredicate predicate,
+                                         ValueHandle lhs, ValueHandle 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.isa<IntegerType>()) &&
+         "only integer comparisons are supported");
+
+  auto op = ScopedContext::getBuilder().create<CmpIOp>(
+      ScopedContext::getLocation(), predicate, lhs.getValue(), rhs.getValue());
+  return ValueHandle(op.getResult());
+}
+
+static ValueHandle createFComparisonExpr(CmpFPredicate predicate,
+                                         ValueHandle lhs, ValueHandle 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());
+}
+
+// All floating point comparison are ordered through EDSL
+ValueHandle mlir::edsc::op::operator==(ValueHandle lhs, ValueHandle 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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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

 //===- MemoryPromotion.cpp - Utilities for moving data across GPU memories ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities that allow one to create IR moving the data
 // across different levels of the GPU memory hierarchy.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/MemoryPromotion.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
-#include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Helpers.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/Functional.h"
 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
+using namespace mlir::edsc;
+using namespace mlir::edsc::intrinsics;
 using namespace mlir::gpu;
 
 /// Returns the textual name of a GPU dimension.
 static StringRef getDimName(unsigned dim) {
   if (dim == 0)
     return "x";
   if (dim == 1)
     return "y";
   if (dim == 2)
     return "z";
 
   llvm_unreachable("dimension ID overflow");
 }
 
 /// Emits the (imperfect) loop nest performing the copy between "from" and "to"
 /// 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,
-                            edsc::MemRefView &bounds, Value from, Value to) {
+                            MemRefBoundsCapture &bounds, Value from, Value to) {
   // Create EDSC handles for bounds.
   unsigned rank = bounds.rank();
-  SmallVector<edsc::ValueHandle, 4> lbs, ubs, steps;
+  SmallVector<ValueHandle, 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;
-    edsc::ValueHandle zero = edsc::intrinsics::constant_index(0);
-    edsc::ValueHandle one = edsc::intrinsics::constant_index(1);
+    ValueHandle zero = std_constant_index(0);
+    ValueHandle 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());
 
   // Emit constant operations for steps.
   steps.reserve(lbs.size());
-  llvm::transform(
-      bounds.getSteps(), std::back_inserter(steps),
-      [](int64_t step) { return edsc::intrinsics::constant_index(step); });
+  llvm::transform(bounds.getSteps(), std::back_inserter(steps),
+                  [](int64_t step) { return std_constant_index(step); });
 
   // Obtain thread identifiers and block sizes, necessary to map to them.
   auto indexType = builder.getIndexType();
   SmallVector<Value, 3> threadIds, blockDims;
   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.
-  auto ivs = edsc::makeIndexHandles(lbs.size());
-  auto ivPtrs =
-      edsc::makeHandlePointers(MutableArrayRef<edsc::IndexHandle>(ivs));
-  edsc::LoopNestBuilder(ivPtrs, lbs, ubs, steps)([&]() {
+  SmallVector<ValueHandle, 8> ivs(lbs.size(), ValueHandle(indexType));
+  auto ivPtrs = makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
+  LoopNestBuilder(ivPtrs, lbs, ubs, steps)([&]() {
     auto activeIvs = llvm::makeArrayRef(ivs).take_back(rank);
-    edsc::StdIndexedValue fromHandle(from), toHandle(to);
+    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>(
static void insertCopies(Region &region, Location loc, Value from, Value to) {
   assert(fromType.getShape() == toType.getShape());
   assert(fromType.getRank() != 0);
   assert(has_single_element(region) &&
          "unstructured control flow not supported");
 
   OpBuilder builder(region.getContext());
   builder.setInsertionPointToStart(&region.front());
 
-  edsc::ScopedContext edscContext(builder, loc);
-  edsc::MemRefView fromView(from);
-  insertCopyLoops(builder, loc, fromView, from, to);
+  ScopedContext edscContext(builder, loc);
+  MemRefBoundsCapture fromBoundsCapture(from);
+  insertCopyLoops(builder, loc, fromBoundsCapture, from, to);
   builder.create<gpu::BarrierOp>(loc);
 
   builder.setInsertionPoint(&region.front().back());
   builder.create<gpu::BarrierOp>(loc);
-  insertCopyLoops(builder, loc, fromView, to, from);
+  insertCopyLoops(builder, loc, fromBoundsCapture, to, from);
 }
 
 /// Promotes a function argument to workgroup memory in the given function. The
 /// copies will be inserted in the beginning and in the end of the function.
 void mlir::promoteToWorkgroupMemory(GPUFuncOp op, unsigned arg) {
   Value value = op.getArgument(arg);
   auto type = value.getType().dyn_cast<MemRefType>();
   assert(type && type.hasStaticShape() && "can only promote memrefs");

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

 //===- Builders.cpp - MLIR Declarative Linalg Builders --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Linalg/EDSC/Builders.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
-#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
-#include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
-#include "mlir/IR/Builders.h"
 #include "mlir/Support/Functional.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
-using namespace mlir::edsc::ops;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
 mlir::edsc::LoopRangeBuilder::LoopRangeBuilder(ValueHandle *iv,
                                                ValueHandle range) {
   assert(range.getType() && "expected !linalg.range type");
   assert(range.getValue().getDefiningOp() &&
          "need operations to extract range parts");
auto fun = [&unaryOp](ArrayRef<BlockArgument> args) {
     ValueHandle a(args[0]);
     linalg_yield(unaryOp(a));
   };
   return makeGenericLinalgOp(iterTypes, {I}, {O}, fun);
 }
 
 Operation *mlir::edsc::ops::linalg_pointwise_tanh(StructuredIndexed I,
                                                   StructuredIndexed O) {
-  using edsc::intrinsics::tanh;
-  UnaryPointwiseOpBuilder unOp([](ValueHandle a) -> Value { return tanh(a); });
+  UnaryPointwiseOpBuilder unOp(
+      [](ValueHandle a) -> Value { return std_tanh(a); });
   return linalg_pointwise(unOp, I, O);
 }
 
 /// Binary pointwise operation (with broadcast) entry point.
 Operation *mlir::edsc::ops::linalg_pointwise(BinaryPointwiseOpBuilder binaryOp,
                                              StructuredIndexed I1,
                                              StructuredIndexed I2,
                                              StructuredIndexed O) {
BinaryPointwiseOpBuilder binOp(
       [](ValueHandle a, ValueHandle b) -> Value { return a + b; });
   return linalg_pointwise(binOp, I1, I2, O);
 }
 
 Operation *mlir::edsc::ops::linalg_pointwise_max(StructuredIndexed I1,
                                                  StructuredIndexed I2,
                                                  StructuredIndexed O) {
   BinaryPointwiseOpBuilder binOp([](ValueHandle a, ValueHandle b) -> Value {
-    using edsc::intrinsics::select;
     using edsc::op::operator>;
-    return select(a > b, a, b).getValue();
+    return std_select(a > b, a, b).getValue();
   });
   return linalg_pointwise(binOp, I1, I2, O);
 }
 
 Operation *mlir::edsc::ops::linalg_matmul(ValueHandle vA, ValueHandle vB,
                                           ValueHandle vC) {
   // clang-format off
   AffineExpr m, n, k;

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

 //===- Fusion.cpp - Implementation of linalg Fusion -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Fusion pass.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Dominance.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
+#include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/EDSC/Helpers.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #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 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
 ///      uses the SSA value of the views and a simple subview/slice analysis to
static LinalgOp fuse(Value producedView, LinalgOp producer, LinalgOp consumer,
   // producer map for `producerIdx`, we need to explicitly compute the view that
   // defines the loop ranges using the `producer`.
   for (unsigned i = 0, nLoops = loopRanges.size(); i < nLoops; ++i) {
     if (loopRanges[i].offset)
       LLVM_DEBUG(llvm::dbgs()
                  << "existing LoopRange: " << loopRanges[i] << "\n");
     else {
       auto viewDim = getViewDefiningLoopRange(producer, i);
-      loopRanges[i] = SubViewOp::Range{constant_index(folder, 0),
-                                       dim(viewDim.view, viewDim.dimension),
-                                       constant_index(folder, 1)};
+      loopRanges[i] = SubViewOp::Range{
+          folded_std_constant_index(folder, 0),
+          std_dim(viewDim.view, viewDim.dimension),
+          folded_std_constant_index(folder, 1)
+      };
       LLVM_DEBUG(llvm::dbgs() << "new LoopRange: " << loopRanges[i] << "\n");
     }
   }
 
   return cloneWithLoopRanges(b, loc, producer, loopRanges);
 }
 
 // Encode structural fusion safety preconditions.

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

 //===- LinalgToLoops.cpp - conversion from Linalg library ops to loops-----===//
 //
 // 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/Linalg/EDSC/Builders.h"
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/LinalgTransforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
-#include "mlir/EDSC/Helpers.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 
-using IndexedStdValue = TemplatedIndexedValue<std_load, std_store>;
-using IndexedAffineValue = TemplatedIndexedValue<affine_load, affine_store>;
-
 using edsc::op::operator+;
 using edsc::op::operator==;
 
 static SmallVector<ValueHandle, 8>
 makeCanonicalAffineApplies(OpBuilder &b, Location loc, AffineMap map,
                            ArrayRef<Value> vals) {
   assert(map.getNumSymbols() == 0);
   assert(map.getNumInputs() == vals.size());
SmallVector<Value, 4> emitLoopRanges(OpBuilder &b, Location loc, AffineMap map,
                                      ArrayRef<Value> allViewSizes) {
   // Apply `map` to get view sizes in loop order.
   auto sizes = applyMapToValues(b, loc, map, allViewSizes);
   // Create a new range with the applied tile sizes.
   ScopedContext scope(b, loc);
   SmallVector<Value, 4> res;
   for (unsigned idx = 0, e = map.getNumResults(); idx < e; ++idx) {
     res.push_back(
-        linalg_range(constant_index(0), sizes[idx], constant_index(1)));
+        linalg_range(std_constant_index(0), sizes[idx], std_constant_index(1)));
   }
   return res;
 }
 
 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<IndexHandle, 8> iivs(inputIvs.begin(), inputIvs.end());
-    SmallVector<IndexHandle, 8> oivs(outputIvs.begin(), outputIvs.end());
+    SmallVector<ValueHandle, 8> iivs(inputIvs.begin(), inputIvs.end());
+    SmallVector<ValueHandle, 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<IndexHandle, 4>(allIvs.begin(), allIvs.begin() + nPar);
+        SmallVector<ValueHandle, 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());
   }
 };
 
 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);
-    IndexHandle r_i(allIvs[0]);
+    ValueHandle 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);
-    IndexHandle i(allIvs[0]), r_j(allIvs[1]);
+    ValueHandle 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);
-    IndexHandle i(allIvs[0]), j(allIvs[1]), r_k(allIvs[2]);
+    ValueHandle 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>
for (unsigned i = 0; i < nOutputs; ++i) {
           b, loc, genericOp.getOutputIndexingMap(i), allIvs));
       indexedValues[nInputs + i] =
           std_load(genericOp.getOutputBuffer(i), indexing);
     }
 
     auto funcOp = genericOp.getFunction();
     if (funcOp) {
       // 2. Emit call.
-      Operation *callOp = call(funcOp, indexedValues);
+      Operation *callOp = std_call(funcOp, indexedValues);
       assert(callOp->getNumResults() == genericOp.getNumOutputs());
 
       // 3. Emit std_store.
       for (unsigned i = 0; i < nOutputs; ++i) {
         ValueHandleArray indexing(makeCanonicalAffineApplies(
             b, loc, genericOp.getOutputIndexingMap(i), allIvs));
         std_store(callOp->getResult(i), genericOp.getOutputBuffer(i), indexing);
       }
for (unsigned i = 0; i < nOutputs; ++i) {
       ValueHandleArray indexing(makeCanonicalAffineApplies(
           b, loc, indexedGenericOp.getOutputIndexingMap(i), allIvs));
       indexedValues[nLoops + nInputs + i] =
           std_load(indexedGenericOp.getOutputBuffer(i), indexing);
     }
 
     if (auto funcOp = indexedGenericOp.getFunction()) {
       // 2. Emit call.
-      Operation *callOp = call(funcOp, indexedValues);
+      Operation *callOp = std_call(funcOp, indexedValues);
       assert(callOp->getNumResults() == indexedGenericOp.getNumOutputs());
 
       // 3. Emit std_store.
       for (unsigned i = 0; i < nOutputs; ++i) {
         ValueHandleArray indexing(makeCanonicalAffineApplies(
             b, loc, indexedGenericOp.getOutputIndexingMap(i), allIvs));
         std_store(callOp->getResult(i), indexedGenericOp.getOutputBuffer(i),
                   indexing);
LogicalResult LinalgOpToLoopsImpl<LoopTy, IndexedValueTy, ConcreteOpTy>::doit(
   auto invertedMap =
       inversePermutation(concatAffineMaps(loopToOperandRangesMaps(linalgOp)));
   if (!invertedMap) {
     LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(
         {}, linalgOp);
     return success();
   }
 
-  SmallVector<IndexHandle, 4> allIvs(nLoops);
+  SmallVector<ValueHandle, 4> allIvs(nLoops, ValueHandle(b.getIndexType()));
   SmallVector<ValueHandle *, 4> allPIvs =
-      makeHandlePointers(MutableArrayRef<IndexHandle>(allIvs));
+      makeHandlePointers(MutableArrayRef<ValueHandle>(allIvs));
   auto loopRanges = emitLoopRanges(scope.getBuilder(), scope.getLocation(),
                                    invertedMap, getViewSizes(b, linalgOp));
   assert(loopRanges.size() == allIvs.size());
 
   GenericLoopNestRangeBuilder<LoopTy>(allPIvs, loopRanges)([&] {
-    auto allIvValues = extractValues(allIvs);
+    SmallVector<Value, 4> allIvValues(allIvs.begin(), allIvs.end());
     LinalgScopedEmitter<IndexedValueTy, ConcreteOpTy>::emitScalarImplementation(
         allIvValues, linalgOp);
   });
   return success();
 }
 
 template <typename LoopType, typename IndexedValueType, typename ConcreteOp>
 class LinalgRewritePattern : public RewritePattern {
void LowerLinalgToLoopsPass<LoopType, IndexedValueType>::runOnFunction() {
   AffineApplyOp::getCanonicalizationPatterns(patterns, context);
   patterns.insert<FoldAffineOp>(context);
   // Just apply the patterns greedily.
   applyPatternsGreedily(this->getFunction(), patterns);
 }
 
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createConvertLinalgToLoopsPass() {
   return std::make_unique<
-      LowerLinalgToLoopsPass<loop::ForOp, IndexedStdValue>>();
+      LowerLinalgToLoopsPass<loop::ForOp, StdIndexedValue>>();
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createConvertLinalgToParallelLoopsPass() {
   return std::make_unique<
-      LowerLinalgToLoopsPass<loop::ParallelOp, IndexedStdValue>>();
+      LowerLinalgToLoopsPass<loop::ParallelOp, StdIndexedValue>>();
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createConvertLinalgToAffineLoopsPass() {
   return std::make_unique<
-      LowerLinalgToLoopsPass<AffineForOp, IndexedAffineValue>>();
+      LowerLinalgToLoopsPass<AffineForOp, AffineIndexedValue>>();
 }
 
 /// Emits a loop nest of `loop.for` with the proper body for `op`.
 template <typename ConcreteOp>
 LogicalResult mlir::linalg::linalgOpToLoops(PatternRewriter &rewriter,
                                             Operation *op) {
-  return LinalgOpToLoopsImpl<loop::ForOp, IndexedStdValue, ConcreteOp>::doit(
+  return LinalgOpToLoopsImpl<loop::ForOp, StdIndexedValue, ConcreteOp>::doit(
       op, rewriter);
 }
 
 /// Emits a loop nest of `affine.for` with the proper body for `op`.
 template <typename ConcreteOp>
 LogicalResult mlir::linalg::linalgOpToAffineLoops(PatternRewriter &rewriter,
                                                   Operation *op) {
-  return LinalgOpToLoopsImpl<AffineForOp, IndexedAffineValue, ConcreteOp>::doit(
+  return LinalgOpToLoopsImpl<AffineForOp, AffineIndexedValue, ConcreteOp>::doit(
       op, rewriter);
 }
 
 /// Emits a loop nest of `loop.parallel` with the proper body for `op`.
 template <typename ConcreteOp>
 LogicalResult mlir::linalg::linalgOpToParallelLoops(PatternRewriter &rewriter,
                                                     Operation *op) {
-  return LinalgOpToLoopsImpl<loop::ParallelOp, IndexedStdValue,
+  return LinalgOpToLoopsImpl<loop::ParallelOp, StdIndexedValue,
                              ConcreteOp>::doit(op, rewriter);
 }
 
 // TODO(ntv) Need to make these instantiations more future-proof to avoid the
 // need to update as soon as we add new ops.
 #define INSTANTIATE_LINALG_OP_TO_LOOPS(OP_TYPE)                                \
   template LogicalResult mlir::linalg::linalgOpToLoops<OP_TYPE>(               \
       PatternRewriter & rewriter, Operation * op);                             \

 INSTANTIATE_LINALG_OP_TO_LOOPS(IndexedGenericOp)
 
 // TODO(pifon): Enable lowering to parallel loops for ops other than
 // linalg.generic for now to be on the safe side.
 template LogicalResult
 mlir::linalg::linalgOpToParallelLoops<GenericOp>(PatternRewriter &rewriter,
                                                  Operation *op);
 
-static PassRegistration<LowerLinalgToLoopsPass<loop::ForOp, IndexedStdValue>>
+static PassRegistration<LowerLinalgToLoopsPass<loop::ForOp, StdIndexedValue>>
     structuredLoopsPass(
         "convert-linalg-to-loops",
         "Lower the operations from the linalg dialect into loops");
 
 static PassRegistration<
-    LowerLinalgToLoopsPass<loop::ParallelOp, IndexedStdValue>>
+    LowerLinalgToLoopsPass<loop::ParallelOp, StdIndexedValue>>
     parallelLoopsPass(
         "convert-linalg-to-parallel-loops",
         "Lower the operations from the linalg dialect into parallel loops");
 
-static PassRegistration<LowerLinalgToLoopsPass<AffineForOp, IndexedAffineValue>>
+static PassRegistration<LowerLinalgToLoopsPass<AffineForOp, AffineIndexedValue>>
     affineLoopsPass(
         "convert-linalg-to-affine-loops",
         "Lower the operations from the linalg dialect into affine loops");

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

 //===- LinalgTransforms.cpp - Linalg transformations as patterns ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements logic for transforming Linalg operations.
 //
 //===----------------------------------------------------------------------===//
 
 #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/VectorOps/VectorOps.h"
-#include "mlir/EDSC/Helpers.h"
-#include "mlir/EDSC/Intrinsics.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"
 #include <type_traits>
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 edsc::intrinsics::std_load;
-  using edsc::intrinsics::std_store;
   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() &&

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

 //===- Promotion.cpp - Implementation of linalg Promotion -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Promotion pass.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/EDSC/Helpers.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 #include "llvm/ADT/SetVector.h"
 #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_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
+using folded_std_constant_float = folded::ValueBuilder<ConstantFloatOp>;
+using folded_std_dim = folded::ValueBuilder<DimOp>;
+using folded_std_muli = folded::ValueBuilder<MulIOp>;
+using folded_linalg_range = folded::ValueBuilder<RangeOp>;
+
 using llvm::SetVector;
 
 #define DEBUG_TYPE "linalg-promotion"
 
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 static llvm::cl::opt<bool> clPromoteDynamic(
     "test-linalg-promote-dynamic",
     llvm::cl::desc("Test generation of dynamic promoted buffers"),
     llvm::cl::cat(clOptionsCategory), llvm::cl::init(false));
 
 static Value allocBuffer(Type elementType, Value size, bool dynamicBuffers) {
   auto *ctx = size.getContext();
   auto width = llvm::divideCeil(elementType.getIntOrFloatBitWidth(), 8);
   if (!dynamicBuffers)
     if (auto cst = dyn_cast_or_null<ConstantIndexOp>(size.getDefiningOp()))
-      return alloc(
+      return std_alloc(
           MemRefType::get(width * cst.getValue(), IntegerType::get(8, ctx)));
-  Value mul = muli(constant_index(width), size);
-  return alloc(MemRefType::get(-1, IntegerType::get(8, ctx)), mul);
+  Value mul = std_muli(std_constant_index(width), size);
+  return std_alloc(MemRefType::get(-1, IntegerType::get(8, ctx)), mul);
 }
 
 // Performs promotion of a `subView` into a local buffer of the size of the
 // *ranges* of the `subView`. This produces a buffer whose size may be bigger
 // than the actual size of the `subView` at the boundaries.
 // This is related to the full/partial tile problem.
 // Returns a PromotionInfo containing a `buffer`, `fullLocalView` and
 // `partialLocalView` such that:
 //   * `buffer` is always the size of the full tile.
 //   * `fullLocalView` is a dense contiguous view into that buffer.
 //   * `partialLocalView` is a dense non-contiguous slice of `fullLocalView`
 //     that corresponds to the size of `subView` and accounting for boundary
 //     effects.
 // The point of the full tile buffer is that constant static tile sizes are
 // folded and result in a buffer type with statically known size and alignment
 // properties.
 // To account for general boundary effects, padding must be performed on the
 // boundary tiles. For now this is done with an unconditional `fill` op followed
 // by a partial `copy` op.
 static PromotionInfo promoteFullTileBuffer(OpBuilder &b, Location loc,
                                            SubViewOp subView,
                                            bool dynamicBuffers,
                                            OperationFolder *folder) {
-  auto zero = constant_index(folder, 0);
-  auto one = constant_index(folder, 1);
+  auto zero = folded_std_constant_index(folder, 0);
+  auto one = folded_std_constant_index(folder, 1);
 
   auto viewType = subView.getType();
   auto rank = viewType.getRank();
   Value allocSize = one;
   SmallVector<Value, 8> fullRanges, partialRanges;
   fullRanges.reserve(rank);
   partialRanges.reserve(rank);
   for (auto en : llvm::enumerate(subView.getRanges())) {
     auto rank = en.index();
     auto rangeValue = en.value();
     Value d = rangeValue.size;
-    allocSize = muli(folder, allocSize, d).getValue();
+    allocSize = folded_std_muli(folder, allocSize, d).getValue();
     fullRanges.push_back(d);
     partialRanges.push_back(
-        linalg_range(folder, zero, dim(subView, rank), one));
+        folded_linalg_range(folder, zero, std_dim(subView, rank), one));
   }
   SmallVector<int64_t, 4> dynSizes(fullRanges.size(), -1);
   auto buffer =
       allocBuffer(viewType.getElementType(), allocSize, dynamicBuffers);
-  auto fullLocalView = view(
+  auto fullLocalView = std_view(
       MemRefType::get(dynSizes, viewType.getElementType()), buffer, fullRanges);
   auto partialLocalView = linalg_slice(fullLocalView, partialRanges);
   return PromotionInfo{buffer, fullLocalView, partialLocalView};
 }
 
 SmallVector<PromotionInfo, 8>
 mlir::linalg::promoteSubViews(OpBuilder &b, Location loc,
                               ArrayRef<Value> subViews, bool dynamicBuffers,
mlir::linalg::promoteSubViews(OpBuilder &b, Location loc,
   for (auto v : subViews) {
     SubViewOp subView = cast<SubViewOp>(v.getDefiningOp());
     auto info = promotionInfoMap.find(v);
     if (info == promotionInfoMap.end())
       continue;
     // TODO(ntv): value to fill with should be related to the operation.
     // For now, just use APFloat(0.0f).
     auto t = subView.getType().getElementType().cast<FloatType>();
-    Value fillVal = constant_float(folder, APFloat(0.0f), t);
+    Value fillVal = folded_std_constant_float(folder, APFloat(0.0f), t);
     // TODO(ntv): fill is only necessary if `promotionInfo` has a full local
     // view that is different from the partial local view and we are on the
     // boundary.
     linalg_fill(info->second.fullLocalView, fillVal);
   }
 
   for (auto v : subViews) {
     auto info = promotionInfoMap.find(v);
bool isOutput =
         op.getIndexOfOutputBuffer(viewAndPartialLocalView.first).hasValue();
     if (isOutput)
       linalg_copy(viewAndPartialLocalView.second,
                   viewAndPartialLocalView.first);
   }
 
   // 4. Dealloc local buffers.
   for (const auto &pi : promotedBufferAndViews)
-    dealloc(pi.buffer);
+    std_dealloc(pi.buffer);
 
   return res;
 }
 
 static void promoteSubViews(FuncOp f, bool dynamicBuffers) {
   SmallVector<LinalgOp, 8> toErase;
   OperationFolder folder(f.getContext());
   f.walk([dynamicBuffers, &folder, &toErase](LinalgOp op) {

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

 //===- Tiling.cpp - Implementation of linalg Tiling -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Tiling pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Linalg/EDSC/Builders.h"
-#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
+#include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/LoopOps/LoopOps.h"
-#include "mlir/EDSC/Helpers.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 #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_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
+using folded_std_dim = folded::ValueBuilder<DimOp>;
+
 #define DEBUG_TYPE "linalg-tiling"
 
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 static llvm::cl::list<unsigned>
     clTileSizes("linalg-tile-sizes",
                 llvm::cl::desc("Tile sizes by which to tile linalg operations"),
                 llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated,
                 llvm::cl::cat(clOptionsCategory));
if (isZero(tileSizes[idx - zerosCount])) {
       continue;
     }
     loopIndexToRangeIndex[idx] = idx - zerosCount;
   }
 
   // Create a new range with the applied tile sizes.
   SmallVector<SubViewOp::Range, 4> res;
   for (unsigned idx = 0, e = tileSizes.size(); idx < e; ++idx) {
-    res.push_back(SubViewOp::Range{constant_index(folder, 0), viewSizes[idx],
-                                   tileSizes[idx]});
+    res.push_back(SubViewOp::Range{folded_std_constant_index(folder, 0),
+                                   viewSizes[idx], tileSizes[idx]});
   }
   return std::make_tuple(res, loopIndexToRangeIndex);
 }
 
 namespace {
 
 // Helper visitor to determine whether an AffineExpr is tiled.
 // This is achieved by traversing every AffineDimExpr with position `pos` and
makeTiledViews(OpBuilder &b, Location loc, LinalgOp linalgOp,
                ArrayRef<Value> viewSizes, OperationFolder *folder) {
   assert(linalgOp.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   assert(ivs.size() == static_cast<size_t>(llvm::count_if(
                            llvm::make_range(tileSizes.begin(), tileSizes.end()),
                            [](Value v) { return !isZero(v); })) &&
          "expected as many ivs as non-zero sizes");
 
-  using edsc::intrinsics::select;
-  using edsc::op::operator+;
-  using edsc::op::operator<;
+  using namespace edsc::op;
 
   // Construct (potentially temporary) mins and maxes on which to apply maps
   // that define tile subviews.
   SmallVector<Value, 8> lbs, subViewSizes;
   for (unsigned idx = 0, idxIvs = 0, e = tileSizes.size(); idx < e; ++idx) {
     bool isTiled = !isZero(tileSizes[idx]);
-    lbs.push_back(isTiled ? ivs[idxIvs++] : (Value)constant_index(folder, 0));
+    lbs.push_back(isTiled ? ivs[idxIvs++]
+                          : (Value)folded_std_constant_index(folder, 0));
     subViewSizes.push_back(isTiled ? tileSizes[idx] : viewSizes[idx]);
   }
 
   auto *op = linalgOp.getOperation();
 
   SmallVector<Value, 4> res;
   res.reserve(op->getNumOperands());
   auto viewIteratorBegin = linalgOp.getInputsAndOutputBuffers().begin();
for (unsigned viewIndex = 0; viewIndex < linalgOp.getNumInputsAndOutputs();
 
     // Construct a new subview for the tile.
     SmallVector<Value, 4> offsets, sizes, strides;
     offsets.reserve(rank);
     sizes.reserve(rank);
     strides.reserve(rank);
     for (unsigned r = 0; r < rank; ++r) {
       if (!isTiled(map.getSubMap({r}), tileSizes)) {
-        offsets.push_back(constant_index(folder, 0));
-        sizes.push_back(dim(view, r));
-        strides.push_back(constant_index(folder, 1));
+        offsets.push_back(folded_std_constant_index(folder, 0));
+        sizes.push_back(std_dim(view, r));
+        strides.push_back(folded_std_constant_index(folder, 1));
         continue;
       }
 
       // Tiling creates a new slice at the proper index, the slice step is 1
       // (i.e. the slice view does not subsample, stepping occurs in the loop).
       auto m = map.getSubMap({r});
       auto offset = applyMapToValues(b, loc, m, lbs, folder).front();
       offsets.push_back(offset);
       auto size = applyMapToValues(b, loc, m, subViewSizes, folder).front();
 
       // The size of the subview should be trimmed to avoid out-of-bounds
       // accesses, unless we statically know the subview size divides the view
       // size evenly.
       int64_t viewSize = viewType.getDimSize(r);
       auto sizeCst = dyn_cast_or_null<ConstantIndexOp>(size.getDefiningOp());
       if (ShapedType::isDynamic(viewSize) || !sizeCst ||
           (viewSize % sizeCst.getValue()) != 0) {
         // Compute min(size, dim - offset) to avoid out-of-bounds accesses.
         auto minMap = AffineMap::get(
             /*dimCount=*/3, /*symbolCount=*/0,
             {getAffineDimExpr(/*position=*/0, b.getContext()),
              getAffineDimExpr(/*position=*/1, b.getContext()) -
                  getAffineDimExpr(/*position=*/2, b.getContext())});
-        auto d = dim(folder, view, r);
-        size = affine_min(folder, b.getIndexType(), minMap,
+        auto d = folded_std_dim(folder, view, r);
+        size = folded_affine_min(folder, b.getIndexType(), minMap,
                                  ValueRange{size, d, offset});
       }
 
       sizes.push_back(size);
-      strides.push_back(constant_index(folder, 1));
+      strides.push_back(folded_std_constant_index(folder, 1));
     }
 
     res.push_back(b.create<SubViewOp>(loc, view, offsets, sizes, strides));
   }
 
   // Traverse the mins/maxes and erase those that don't have uses left.
   // This is a special type of folding that we only apply when `folder` is
   // defined.
tileLinalgOpImpl(OpBuilder &b, LinalgOp op, ArrayRef<Value> tileSizes,
   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;
-  SmallVector<IndexHandle, 4> ivs(loopRanges.size());
-  auto pivs = makeHandlePointers(MutableArrayRef<IndexHandle>(ivs));
+  auto ivs = ValueHandle::makeIndexHandles(loopRanges.size());
+  auto pivs = makeHandlePointers(MutableArrayRef<ValueHandle>(ivs));
   // 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)([&] {
     auto b = ScopedContext::getBuilder();
tileLinalgOpImpl(OpBuilder &b, LinalgOp op, ArrayRef<int64_t> tileSizes,
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(op);
   ScopedContext scope(b, op.getLoc());
 
   // Materialize concrete tile size values to pass the generic tiling function.
   SmallVector<Value, 8> tileSizeValues;
   tileSizeValues.reserve(tileSizes.size());
   for (auto ts : tileSizes)
-    tileSizeValues.push_back(constant_index(folder, ts));
+    tileSizeValues.push_back(folded_std_constant_index(folder, ts));
   // Pad tile sizes with zero values to enforce our convention.
   if (tileSizeValues.size() < nLoops) {
     for (unsigned i = tileSizeValues.size(); i < nLoops; ++i)
-      tileSizeValues.push_back(constant_index(folder, 0));
+      tileSizeValues.push_back(folded_std_constant_index(folder, 0));
   }
 
   return tileLinalgOpImpl<LoopTy>(b, op, tileSizeValues, permutation, folder);
 }
 
 Optional<TiledLinalgOp>
 mlir::linalg::tileLinalgOp(OpBuilder &b, LinalgOp op, ArrayRef<Value> tileSizes,
                            ArrayRef<unsigned> permutation,

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 //===- Utils.cpp - Utilities to support the Linalg dialect ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities for the Linalg dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
+#include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/StandardOps/Ops.h"
-#include "mlir/EDSC/Helpers.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/STLExtras.h"
 #include "mlir/Transforms/FoldUtils.h"
 
 using namespace mlir;
-using namespace mlir::edsc;
-using namespace mlir::edsc::intrinsics;
 using namespace mlir::linalg;
 using namespace mlir::loop;
 
 Optional<RegionMatcher::BinaryOpKind>
 RegionMatcher::matchAsScalarBinaryOp(GenericOp op) {
   auto &region = op.region();
   if (!has_single_element(region))
     return llvm::None;

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) {
+  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) {
+  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),
+                                       std::get<2>(it), std::get<3>(it)));
+  }
+  assert(loops.size() == ivs.size() && "Mismatch loops vs ivs size");
+}
+
+void mlir::edsc::LoopNestBuilder::LoopNestBuilder::operator()(
+    std::function<void(void)> fun) {
+  if (fun)
+    fun();
+  for (auto &lit : reverse(loops))
+    lit({});
+}
+
+LoopBuilder mlir::edsc::makeParallelLoopBuilder(ArrayRef<ValueHandle *> ivs,
+                                                ArrayRef<ValueHandle> lbHandles,
+                                                ArrayRef<ValueHandle> ubHandles,
+                                                ArrayRef<ValueHandle> 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));
+  result.enter(parallelOp.getBody(), /*prev=*/1);
+  return result;
+}
+
+mlir::edsc::LoopBuilder mlir::edsc::makeLoopBuilder(ValueHandle *iv,
+                                                    ValueHandle lbHandle,
+                                                    ValueHandle ubHandle,
+                                                    ValueHandle stepHandle) {
+  mlir::edsc::LoopBuilder result;
+  auto forOp =
+      OperationHandle::createOp<loop::ForOp>(lbHandle, ubHandle, stepHandle);
+  *iv = ValueHandle(forOp.getInductionVar());
+  auto *body = loop::getForInductionVarOwner(iv->getValue()).getBody();
+  result.enter(body, /*prev=*/1);
+  return result;
+}

mlir/lib/Dialect/StandardOps/CMakeLists.txt

 file(GLOB globbed *.c *.cpp)
 add_llvm_library(MLIRStandardOps
   ${globbed}
+  EDSC/Intrinsics.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/StandardOps
   )
 add_dependencies(MLIRStandardOps
   MLIRCallOpInterfacesIncGen
   MLIRStandardOpsIncGen
   MLIRIR
   LLVMSupport
   )
 target_link_libraries(MLIRStandardOps MLIRIR LLVMSupport)

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

-//===- Helpers.cpp - MLIR Declarative Helper Functionality ----------------===//
+//===- 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/EDSC/Helpers.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#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) {
   MemRefType memRefType = memRef.getType().cast<MemRefType>();
   assert(isStrided(memRefType) && "Expected strided MemRef type");
 
   SmallVector<ValueHandle, 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(ValueHandle::create<DimOp>(memRef, idx));
-    } else {
-      res.push_back(static_cast<index_type>(shape[idx]));
-    }
+    if (shape[idx] == -1)
+      res.push_back(std_dim(memRef, idx));
+    else
+      res.push_back(std_constant_index(shape[idx]));
   }
   return res;
 }
 
-mlir::edsc::MemRefView::MemRefView(Value v) : base(v) {
-  assert(v.getType().isa<MemRefType>() && "MemRefType expected");
-
+mlir::edsc::MemRefBoundsCapture::MemRefBoundsCapture(Value v) : base(v) {
   auto memrefSizeValues = getMemRefSizes(v);
-  for (auto &size : memrefSizeValues) {
-    lbs.push_back(static_cast<index_type>(0));
-    ubs.push_back(size);
+  for (auto s : memrefSizeValues) {
+    lbs.push_back(std_constant_index(0));
+    ubs.push_back(s);
     steps.push_back(1);
   }
 }
 
-mlir::edsc::VectorView::VectorView(Value v) : base(v) {
+mlir::edsc::VectorBoundsCapture::VectorBoundsCapture(Value v) : base(v) {
   auto vectorType = v.getType().cast<VectorType>();
-
   for (auto s : vectorType.getShape()) {
-    lbs.push_back(static_cast<index_type>(0));
-    ubs.push_back(static_cast<index_type>(s));
+    lbs.push_back(std_constant_index(0));
+    ubs.push_back(std_constant_index(s));
     steps.push_back(1);
   }
 }

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/EDSC/Intrinsics.h"
-#include "mlir/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
 OperationHandle mlir::edsc::intrinsics::br(BlockHandle bh,
                                            ArrayRef<ValueHandle> operands) {
   assert(bh && "Expected already captured BlockHandle");

mlir/lib/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/EDSC/Builders.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/IR/AffineExpr.h"
+#include "mlir/IR/AffineMap.h"
 
 #include "llvm/ADT/Optional.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
 mlir::edsc::ScopedContext::ScopedContext(OpBuilder &builder, Location location)
     : builder(builder), location(location),
assert(ScopedContext::getCurrentScopedContext() &&
          "Unexpected Null ScopedContext");
   return ScopedContext::getCurrentScopedContext()->location;
 }
 
 MLIRContext *mlir::edsc::ScopedContext::getContext() {
   return getBuilder().getContext();
 }
 
-mlir::edsc::ValueHandle::ValueHandle(index_type cst) {
-  auto &b = ScopedContext::getBuilder();
-  auto loc = ScopedContext::getLocation();
-  v = b.create<ConstantIndexOp>(loc, cst.v).getResult();
-  t = v.getType();
-}
-
 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
-mlir::edsc::ValueHandle::createComposedAffineApply(AffineMap map,
-                                                   ArrayRef<Value> operands) {
-  Operation *op =
-      makeComposedAffineApply(ScopedContext::getBuilder(),
-                              ScopedContext::getLocation(), map, operands)
-          .getOperation();
-  assert(op->getNumResults() == 1 && "Not a single result AffineApply");
-  return ValueHandle(op->getResult(0));
-}
-
 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) {
+  if (op->getNumResults() == 1)
     return ValueHandle(op->getResult(0));
-  }
-  if (auto f = dyn_cast<AffineForOp>(op)) {
-    return ValueHandle(f.getInductionVar());
-  }
   llvm_unreachable("unsupported operation, use an OperationHandle instead");
 }
 
 OperationHandle OperationHandle::create(StringRef name,
                                         ArrayRef<ValueHandle> operands,
                                         ArrayRef<Type> resultTypes,
                                         ArrayRef<NamedAttribute> attributes) {
   OperationState state(ScopedContext::getLocation(), name);
BlockHandle mlir::edsc::BlockHandle::createInRegion(Region &region,
   OpBuilder::InsertionGuard g(currentB);
   currentB.setInsertionPoint(res.block, res.block->begin());
   for (auto t : argTypes) {
     res.block->addArgument(t);
   }
   return res;
 }
 
-static Optional<ValueHandle> emitStaticFor(ArrayRef<ValueHandle> lbs,
-                                           ArrayRef<ValueHandle> ubs,
-                                           int64_t step) {
-  if (lbs.size() != 1 || ubs.size() != 1)
-    return Optional<ValueHandle>();
-
-  auto *lbDef = lbs.front().getValue().getDefiningOp();
-  auto *ubDef = ubs.front().getValue().getDefiningOp();
-  if (!lbDef || !ubDef)
-    return Optional<ValueHandle>();
-
-  auto lbConst = dyn_cast<ConstantIndexOp>(lbDef);
-  auto ubConst = dyn_cast<ConstantIndexOp>(ubDef);
-  if (!lbConst || !ubConst)
-    return Optional<ValueHandle>();
-
-  return ValueHandle::create<AffineForOp>(lbConst.getValue(),
-                                          ubConst.getValue(), step);
-}
-
-mlir::edsc::LoopBuilder mlir::edsc::LoopBuilder::makeAffine(
-    ValueHandle *iv, ArrayRef<ValueHandle> lbHandles,
-    ArrayRef<ValueHandle> ubHandles, int64_t step) {
-  mlir::edsc::LoopBuilder result;
-  if (auto staticFor = emitStaticFor(lbHandles, ubHandles, step)) {
-    *iv = staticFor.getValue();
-  } else {
-    SmallVector<Value, 4> lbs(lbHandles.begin(), lbHandles.end());
-    SmallVector<Value, 4> ubs(ubHandles.begin(), ubHandles.end());
-    *iv = ValueHandle::create<AffineForOp>(
-        lbs, ScopedContext::getBuilder().getMultiDimIdentityMap(lbs.size()),
-        ubs, ScopedContext::getBuilder().getMultiDimIdentityMap(ubs.size()),
-        step);
-  }
-  auto *body = getForInductionVarOwner(iv->getValue()).getBody();
-  result.enter(body, /*prev=*/1);
-  return result;
-}
-
-mlir::edsc::LoopBuilder mlir::edsc::LoopBuilder::makeParallel(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbHandles,
-    ArrayRef<ValueHandle> ubHandles, ArrayRef<ValueHandle> steps) {
-  mlir::edsc::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));
-  result.enter(parallelOp.getBody(), /*prev=*/1);
-  return result;
-}
-
-mlir::edsc::LoopBuilder
-mlir::edsc::LoopBuilder::makeLoop(ValueHandle *iv, ValueHandle lbHandle,
-                                  ValueHandle ubHandle,
-                                  ValueHandle stepHandle) {
-  mlir::edsc::LoopBuilder result;
-  auto forOp =
-      OperationHandle::createOp<loop::ForOp>(lbHandle, ubHandle, stepHandle);
-  *iv = ValueHandle(forOp.getInductionVar());
-  auto *body = loop::getForInductionVarOwner(iv->getValue()).getBody();
-  result.enter(body, /*prev=*/1);
-  return result;
-}
-
 void mlir::edsc::LoopBuilder::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.
   /// The particular use case concerns nested blocks:
   ///
   /// ```c++
   ///    For (&i, lb, ub, 1)({
   ///      /--- destructor for this `For` is not always called before ...
   ///      V
   ///      For (&j1, lb, ub, 1)({
   ///        some_op_1,
   ///      }),
   ///      /--- ... this scope is entered, resulting in improperly nested IR.
   ///      V
   ///      For (&j2, lb, ub, 1)({
   ///        some_op_2,
   ///      }),
   ///    });
   /// ```
   if (fun)
     fun();
   exit();
 }
 
-mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
-    ValueHandle *iv, ArrayRef<ValueHandle> lbs, ArrayRef<ValueHandle> ubs,
-    int64_t step) {
-  loops.emplace_back(LoopBuilder::makeAffine(iv, lbs, ubs, step));
-}
-
-mlir::edsc::AffineLoopNestBuilder::AffineLoopNestBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-    ArrayRef<ValueHandle> 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(LoopBuilder::makeAffine(
-        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)();
-}
-
-mlir::edsc::ParallelLoopNestBuilder::ParallelLoopNestBuilder(
-    ArrayRef<ValueHandle *> ivs, ArrayRef<ValueHandle> lbs,
-    ArrayRef<ValueHandle> ubs, ArrayRef<ValueHandle> 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(LoopBuilder::makeParallel(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) {
-  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(LoopBuilder::makeLoop(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");
-}
-
-void LoopNestBuilder::LoopNestBuilder::operator()(
-    std::function<void(void)> fun) {
-  if (fun)
-    fun();
-  for (auto &lit : reverse(loops))
-    lit({});
-}
-
 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) {
   assert(!*bh && "BlockHandle already captures a block, use "

 /// 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();
 }
-
-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,
-    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);
-  std::tie(d1, v1) =
-      categorizeValueByAffineType(context, rhs.getValue(), numDims, numSymbols);
-  SmallVector<Value, 2> operands;
-  if (v0) {
-    operands.push_back(v0);
-  }
-  if (v1) {
-    operands.push_back(v1);
-  }
-  auto map = AffineMap::get(numDims, numSymbols, {affCombiner(d0, d1)});
-  // TODO: createOrFold when available.
-  return ValueHandle::createComposedAffineApply(map, operands);
-}
-
-template <typename IOp, typename FOp>
-static ValueHandle createBinaryHandle(
-    ValueHandle lhs, ValueHandle rhs,
-    function_ref<AffineExpr(AffineExpr, AffineExpr)> affCombiner) {
-  auto thisType = lhs.getValue().getType();
-  auto thatType = rhs.getValue().getType();
-  assert(thisType == thatType && "cannot mix types in operators");
-  (void)thisType;
-  (void)thatType;
-  if (thisType.isIndex()) {
-    return createBinaryIndexHandle(lhs, rhs, affCombiner);
-  } else if (thisType.isa<IntegerType>()) {
-    return createBinaryHandle<IOp>(lhs, rhs);
-  } else if (thisType.isa<FloatType>()) {
-    return createBinaryHandle<FOp>(lhs, rhs);
-  } else if (thisType.isa<VectorType>() || thisType.isa<TensorType>()) {
-    auto aggregateType = thisType.cast<ShapedType>();
-    if (aggregateType.getElementType().isa<IntegerType>())
-      return createBinaryHandle<IOp>(lhs, rhs);
-    else if (aggregateType.getElementType().isa<FloatType>())
-      return createBinaryHandle<FOp>(lhs, rhs);
-  }
-  llvm_unreachable("failed to create a ValueHandle");
-}
-
-ValueHandle mlir::edsc::op::operator+(ValueHandle lhs, ValueHandle rhs) {
-  return createBinaryHandle<AddIOp, AddFOp>(
-      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 + d1; });
-}
-
-ValueHandle mlir::edsc::op::operator-(ValueHandle lhs, ValueHandle rhs) {
-  return createBinaryHandle<SubIOp, SubFOp>(
-      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 - d1; });
-}
-
-ValueHandle mlir::edsc::op::operator*(ValueHandle lhs, ValueHandle rhs) {
-  return createBinaryHandle<MulIOp, MulFOp>(
-      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 * d1; });
-}
-
-ValueHandle mlir::edsc::op::operator/(ValueHandle lhs, ValueHandle 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) {
-  return createBinaryHandle<SignedRemIOp, RemFOp>(
-      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0 % d1; });
-}
-
-ValueHandle mlir::edsc::op::floorDiv(ValueHandle lhs, ValueHandle rhs) {
-  return createBinaryIndexHandle(
-      lhs, rhs, [](AffineExpr d0, AffineExpr d1) { return d0.floorDiv(d1); });
-}
-
-ValueHandle mlir::edsc::op::ceilDiv(ValueHandle lhs, ValueHandle 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) {
-  assert(lhs.getType().isInteger(1) && "expected boolean expression on LHS");
-  assert(rhs.getType().isInteger(1) && "expected boolean expression on RHS");
-  return lhs * rhs;
-}
-
-ValueHandle mlir::edsc::op::operator||(ValueHandle lhs, ValueHandle rhs) {
-  return !(!lhs && !rhs);
-}
-
-static ValueHandle createIComparisonExpr(CmpIPredicate predicate,
-                                         ValueHandle lhs, ValueHandle 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.isa<IntegerType>()) &&
-         "only integer comparisons are supported");
-
-  auto op = ScopedContext::getBuilder().create<CmpIOp>(
-      ScopedContext::getLocation(), predicate, lhs.getValue(), rhs.getValue());
-  return ValueHandle(op.getResult());
-}
-
-static ValueHandle createFComparisonExpr(CmpFPredicate predicate,
-                                         ValueHandle lhs, ValueHandle 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());
-}
-
-// All floating point comparison are ordered through EDSL
-ValueHandle mlir::edsc::op::operator==(ValueHandle lhs, ValueHandle 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) {
-  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) {
-  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) {
-  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) {
-  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) {
-  auto type = lhs.getType();
-  return type.isa<FloatType>()
-             ? createFComparisonExpr(CmpFPredicate::OGE, lhs, rhs)
-             : createIComparisonExpr(CmpIPredicate::sge, lhs, rhs);
-}

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

 //===- builder-api-test.cpp - Tests for Declarative Builder APIs ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // RUN: mlir-edsc-builder-api-test | FileCheck %s
 
-#include "mlir/Dialect/AffineOps/AffineOps.h"
-#include "mlir/Dialect/Linalg/EDSC/Builders.h"
+#include "mlir/Dialect/AffineOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
-#include "mlir/Dialect/Linalg/IR/LinalgOps.h"
-#include "mlir/Dialect/StandardOps/Ops.h"
+#include "mlir/Dialect/LoopOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/EDSC/Builders.h"
-#include "mlir/EDSC/Helpers.h"
 #include "mlir/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/Functional.h"
 #include "mlir/Transforms/LoopUtils.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "APITest.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
+using namespace mlir::edsc;
+using namespace mlir::edsc::intrinsics;
 
 static MLIRContext &globalContext() {
   static thread_local MLIRContext context;
   return context;
 }
 
 static FuncOp makeFunction(StringRef name, ArrayRef<Type> results = {},
                            ArrayRef<Type> args = {}) {
   auto &ctx = globalContext();
   auto function = FuncOp::create(UnknownLoc::get(&ctx), name,
                                  FunctionType::get(args, results, &ctx));
   function.addEntryBlock();
   return function;
 }
 
 TEST_FUNC(builder_dynamic_for_func_args) {
-  using namespace edsc;
-  using namespace edsc::op;
-  using namespace edsc::intrinsics;
   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(constant_float(llvm::APFloat(7.0f), f32Type));
-  ValueHandle f13(constant_float(llvm::APFloat(13.0f), f32Type));
-  ValueHandle i7(constant_int(7, 32));
-  ValueHandle i13(constant_int(13, 32));
+  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));
   AffineLoopNestBuilder(&i, lb, ub, 3)([&] {
-    lb *index_type(3) + ub;
-    lb + index_type(3);
+    using namespace edsc::op;
+    lb *std_constant_index(3) + ub;
+    lb + std_constant_index(3);
     AffineLoopNestBuilder(&j, lb, ub, 2)([&] {
-      ceilDiv(index_type(31) * floorDiv(i + j * index_type(3), index_type(32)),
-              index_type(32));
+      ceilDiv(std_constant_index(31) * floorDiv(i + j * std_constant_index(3),
+                                                std_constant_index(32)),
+              std_constant_index(32));
       ((f7 + f13) / f7) % f13 - f7 *f13;
       ((i7 + i13) / i7) % i13 - i7 *i13;
     });
   });
 
   // clang-format off
   // CHECK-LABEL: func @builder_dynamic_for_func_args(%{{.*}}: index, %{{.*}}: index) {
   //     CHECK:  affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) step 3 {
TEST_FUNC(builder_dynamic_for_func_args) {
   // CHECK-DAG:    [[ri4:%[0-9]+]] = muli {{.*}}, {{.*}} : i32
   //     CHECK:    {{.*}} = subi [[ri3]], [[ri4]] : i32
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_dynamic_for) {
-  using namespace edsc;
-  using namespace edsc::op;
-  using namespace edsc::intrinsics;
   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));
+  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) {
-  using namespace edsc;
-  using namespace edsc::op;
-  using namespace edsc::intrinsics;
   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));
+  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) {
-  using namespace edsc;
-  using namespace edsc::op;
-  using namespace edsc::intrinsics;
   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));
   AffineLoopNestBuilder(&i, {lb1, lb2}, {ub1, ub2}, 1)();
-  ret();
+  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;
-  using namespace edsc::intrinsics;
   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()),
TEST_FUNC(builder_blocks) {
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: }
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_blocks_eager) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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()),
TEST_FUNC(builder_blocks_eager) {
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: }
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_cond_branch) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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());
 
   BlockHandle b1, b2, functionBlock(&f.front());
-  BlockBuilder(&b1, {&arg1})([&] { ret(); });
-  BlockBuilder(&b2, {&arg2, &arg3})([&] { ret(); });
+  BlockBuilder(&b1, {&arg1})([&] { std_ret(); });
+  BlockBuilder(&b2, {&arg2, &arg3})([&] { std_ret(); });
   // Get back to entry block and add a conditional branch
   BlockBuilder(functionBlock, Append())([&] {
     cond_br(funcArg, b1, {c32}, b2, {c64, c42});
   });
 
   // clang-format off
   // CHECK-LABEL: @builder_cond_branch
   // 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_cond_branch_eager) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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());
 
   // clang-format off
   BlockHandle b1, b2;
   cond_br(funcArg, &b1, {&arg1}, {c32}, &b2, {&arg2, &arg3}, {c64, c42});
   BlockBuilder(b1, Append())([]{
-      ret();
+      std_ret();
   });
   BlockBuilder(b2, Append())([]{
-      ret();
+      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;
-  using namespace edsc::intrinsics;
   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));
-  MemRefView vA(f.getArgument(0)), vB(f.getArgument(1)),
+  MemRefBoundsCapture vA(f.getArgument(0)), vB(f.getArgument(1)),
       vC(f.getArgument(2));
-  IndexedValue A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
-  IndexHandle i, j, k1, k2, lb0, lb1, lb2, ub0, ub1, ub2;
+  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);
   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(&k1, lb2, ub2, step2)([&]{
TEST_FUNC(builder_helpers) {
   //  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;
-  using namespace edsc::intrinsics;
   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;
-  IndexHandle m, n, M(f.getArgument(0)), N(f.getArgument(1));
-  IndexHandle ten(index_type(10)), twenty(index_type(20));
+  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;
-  using namespace edsc::intrinsics;
   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);
   });
   ValueHandle::create<ConstantIntOp>(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_sign_extendi_op_i1_to_i8) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
+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_sign_extendi_op", {}, {memrefType, memrefType});
+  auto f = makeFunction("zero_and_std_sign_extendi_op", {},
+                        {memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
-  IndexedValue A(f.getArgument(0));
-  IndexedValue B(f.getArgument(1));
+  AffineIndexedValue A(f.getArgument(0));
+  AffineIndexedValue B(f.getArgument(1));
   // clang-format off
-  edsc::intrinsics::zero_extendi(*A, i8Type);
-  edsc::intrinsics::sign_extendi(*B, i8Type);
-  // CHECK-LABEL: @zero_and_sign_extendi_op
+  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(select_op_i32) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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 = constant_index(0), one = constant_index(1);
-  MemRefView vA(f.getArgument(0));
-  IndexedValue A(f.getArgument(0));
-  IndexHandle i, j;
+  ValueHandle 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 IndexedValue::operator Value.
+    // This test exercises AffineIndexedValue::operator Value.
     // Without it, one must force conversion to ValueHandle as such:
-    //   edsc::intrinsics::select(
+    //   std_select(
     //      i == zero, ValueHandle(A(zero, zero)), ValueHandle(ValueA(i, j)))
-    edsc::intrinsics::select(i == zero, *A(zero, zero), *A(i, j));
+    using edsc::op::operator==;
+    std_select(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) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
-  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, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   // clang-format off
-  ValueHandle zero = constant_index(0), one = constant_index(1);
-  MemRefView vA(f.getArgument(0)), vB(f.getArgument(1));
-  IndexedValue A(f.getArgument(0)), B(f.getArgument(1));
-  IndexHandle i, j;
+  ValueHandle 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})([&]{
-
-    edsc::intrinsics::select(B(i, j) == B(i+one, j), *A(zero, zero), *A(i, j));
-    edsc::intrinsics::select(B(i, j) != B(i+one, j), *A(zero, zero), *A(i, j));
-    edsc::intrinsics::select(B(i, j) >= B(i+one, j), *A(zero, zero), *A(i, j));
-    edsc::intrinsics::select(B(i, j) <= B(i+one, j), *A(zero, zero), *A(i, j));
-    edsc::intrinsics::select(B(i, j) < B(i+one, j), *A(zero, zero), *A(i, j));
-    edsc::intrinsics::select(B(i, j) > B(i+one, j), *A(zero, zero), *A(i, j));
+    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));
   });
 
   // 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) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
-  using namespace edsc::op;
+  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 = constant_index(0);
-  MemRefView vA(f.getArgument(0)), vB(f.getArgument(1)), vC(f.getArgument(2));
-  IndexedValue A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
-  IndexHandle i, j, k1, k2, M(vC.ub(0)), N(vC.ub(1)), O(vC.ub(2));
+  ValueHandle 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));
 
   // clang-format off
+  using namespace edsc::op;
   AffineLoopNestBuilder({&i, &j}, {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);
     });
   });
TEST_FUNC(tile_2d) {
   //  CHECK-NEXT:             affine.store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 // Exercise StdIndexedValue for loads and stores.
 TEST_FUNC(indirect_access) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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 = constant_index(0);
-  MemRefView vC(f.getArgument(2));
-  IndexedValue B(f.getArgument(1)), D(f.getArgument(3));
+  ValueHandle 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));
-  IndexHandle i, N(vC.ub(0));
+  ValueHandle i(builder.getIndexType()), N(vC.ub(0));
 
   // clang-format off
   AffineLoopNestBuilder(&i, zero, N, 1)([&]{
       C((ValueHandle)D(i)) = A((ValueHandle)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]]
   // CHECK:  load %{{.*}}{{\[}}[[B]]{{\]}}
   // CHECK:  store %{{.*}}, %{{.*}}{{\[}}[[D]]{{\]}}
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 // Exercise affine loads and stores build with empty maps.
 TEST_FUNC(empty_map_load_store) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   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 = constant_index(0);
-  ValueHandle one = constant_index(1);
-  IndexedValue input(f.getArgument(0)), res(f.getArgument(1));
-  IndexHandle iv;
+  ValueHandle zero = std_constant_index(0);
+  ValueHandle one = std_constant_index(1);
+  AffineIndexedValue input(f.getArgument(0)), res(f.getArgument(1));
+  ValueHandle iv(builder.getIndexType());
 
   // clang-format off
   AffineLoopNestBuilder(&iv, zero, one, 1)([&]{
       res() = input();
   });
   // clang-format on
 
   // clang-format off
   // CHECK-LABEL: func @empty_map_load_store(
   // CHECK:  [[A:%.*]] = affine.load %{{.*}}[]
   // CHECK:  affine.store [[A]], %{{.*}}[]
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @affine_if_op
 // CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
 // CHECK-NOT:   else
 // CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
 // CHECK-NEXT: } else {
 // clang-format on
 TEST_FUNC(affine_if_op) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
   using namespace edsc::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 = constant_index(0), ten = constant_index(10);
+  ValueHandle 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
   };

 }
 
 // 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) {
-  using namespace edsc;
-  using namespace edsc::intrinsics;
-
   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);