[mlir][MemRef] NFC - Drop MemRef EDSC usage

[nicolasvasilache]

Summary

Drop the MemRef dialect EDSC subdirectory and update all uses.

[bkramer]

looks good

[mehdi_amini]

mlir/include/mlir/IR/ImplicitLocOpBuilder.h

98

(Nit: this entire file change is just formatting apparently)

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 //===- Utils.h - Utilities to support the Linalg dialect --------*- 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_UTILS_H_
 #define MLIR_DIALECT_LINALG_UTILS_H_
 
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
-#include "mlir/Dialect/MemRef/EDSC/Intrinsics.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 
 namespace mlir {
 class AffineExpr;

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

-//===- Intrinsics.h - MLIR EDSC Intrinsics for MemRefOps --------*- 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_MEMREF_EDSC_INTRINSICS_H_
-#define MLIR_DIALECT_MEMREF_EDSC_INTRINSICS_H_
-
-#include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/StandardOps/EDSC/Builders.h"
-#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
-#include "mlir/EDSC/Builders.h"
-
-#include "llvm/ADT/SmallVector.h"
-
-namespace mlir {
-namespace edsc {
-namespace intrinsics {
-
-using memref_alloc = ValueBuilder<memref::AllocOp>;
-using memref_alloca = ValueBuilder<memref::AllocaOp>;
-using memref_cast = ValueBuilder<memref::CastOp>;
-using memref_dealloc = OperationBuilder<memref::DeallocOp>;
-using memref_dim = ValueBuilder<memref::DimOp>;
-using memref_load = ValueBuilder<memref::LoadOp>;
-using memref_store = OperationBuilder<memref::StoreOp>;
-using memref_sub_view = ValueBuilder<memref::SubViewOp>;
-using memref_tensor_load = ValueBuilder<memref::TensorLoadOp>;
-using memref_tensor_store = OperationBuilder<memref::TensorStoreOp>;
-using memref_view = ValueBuilder<memref::ViewOp>;
-
-} // namespace intrinsics
-} // namespace edsc
-} // namespace mlir
-
-static inline ::llvm::SmallVector<mlir::Value, 8>
-getMemRefSizes(mlir::Value memRef) {
-  using namespace mlir;
-  using namespace mlir::edsc;
-  using namespace mlir::edsc::intrinsics;
-  mlir::MemRefType memRefType = memRef.getType().cast<mlir::MemRefType>();
-  assert(isStrided(memRefType) && "Expected strided MemRef type");
-
-  SmallVector<mlir::Value, 8> res;
-  res.reserve(memRefType.getShape().size());
-  const auto &shape = memRefType.getShape();
-  for (unsigned idx = 0, n = shape.size(); idx < n; ++idx) {
-    if (shape[idx] == -1)
-      res.push_back(memref_dim(memRef, idx));
-    else
-      res.push_back(std_constant_index(shape[idx]));
-  }
-  return res;
-}
-
-namespace mlir {
-namespace edsc {
-
-/// 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: Support MemRefs with layoutMaps.
-class MemRefBoundsCapture : public BoundsCapture {
-public:
-  explicit MemRefBoundsCapture(Value v) {
-    auto memrefSizeValues = getMemRefSizes(v);
-    for (auto s : memrefSizeValues) {
-      lbs.push_back(intrinsics::std_constant_index(0));
-      ubs.push_back(s);
-      steps.push_back(1);
-    }
-  }
-
-  unsigned fastestVarying() const { return rank() - 1; }
-
-private:
-  Value base;
-};
-
-} // namespace edsc
-} // namespace mlir
-
-#endif // MLIR_DIALECT_MEMREF_EDSC_INTRINSICS_H_

mlir/include/mlir/IR/ImplicitLocOpBuilder.h

public:
 
   // We allow clients to use the explicit-loc version of create as well.
   using OpBuilder::create;
   using OpBuilder::createOrFold;
 
   /// Create an operation of specific op type at the current insertion point and
   /// location.
   template <typename OpTy, typename... Args>
-  OpTy create(Args &&... args) {
+  OpTy create(Args &&...args) {
     return OpBuilder::create<OpTy>(curLoc, std::forward<Args>(args)...);
   }
 
   /// Create an operation of specific op type at the current insertion point,
   /// and immediately try to fold it. This functions populates 'results' with
   /// the results after folding the operation.
   template <typename OpTy, typename... Args>
-  void createOrFold(llvm::SmallVectorImpl<Value> &results, Args &&... args) {
+  void createOrFold(llvm::SmallVectorImpl<Value> &results, Args &&...args) {
     OpBuilder::createOrFold<OpTy>(results, curLoc, std::forward<Args>(args)...);
   }
 
   /// Overload to create or fold a single result operation.
   template <typename OpTy, typename... Args>
   typename std::enable_if<OpTy::template hasTrait<mlir::OpTrait::OneResult>(),
                           Value>::type
-  createOrFold(Args &&... args) {
+  createOrFold(Args &&...args) {
     return OpBuilder::createOrFold<OpTy>(curLoc, std::forward<Args>(args)...);
   }
 
   /// Overload to create or fold a zero result operation.
   template <typename OpTy, typename... Args>
   typename std::enable_if<OpTy::template hasTrait<mlir::OpTrait::ZeroResult>(),
                           OpTy>::type
-  createOrFold(Args &&... args) {
+  createOrFold(Args &&...args) {
     return OpBuilder::createOrFold<OpTy>(curLoc, std::forward<Args>(args)...);
   }
 
   /// This builder can also be used to emit diagnostics to the current location.
   mlir::InFlightDiagnostic
   emitError(const llvm::Twine &message = llvm::Twine()) {
     return mlir::emitError(curLoc, message);
   }
   mlir::InFlightDiagnostic
   emitWarning(const llvm::Twine &message = llvm::Twine()) {
     return mlir::emitWarning(curLoc, message);
   }
   mlir::InFlightDiagnostic
   emitRemark(const llvm::Twine &message = llvm::Twine()) {
     return mlir::emitRemark(curLoc, message);
   }
 
 private:
   Location curLoc;
 };
 
 } // namespace mlir
 
 #endif // MLIR_IR_IMPLICITLOCOPBUILDER_H

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/MemRef/EDSC/Intrinsics.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
+#include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 using namespace mlir::gpu;
 
static StringRef getDimName(unsigned dim) {
   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 &b, Location loc,
-                            MemRefBoundsCapture &bounds, Value from, Value to) {
-  // Create EDSC handles for bounds.
-  unsigned rank = bounds.rank();
+static void insertCopyLoops(ImplicitLocOpBuilder &b, Value from, Value to) {
+  auto memRefType = from.getType().cast<MemRefType>();
+  auto rank = memRefType.getRank();
+
   SmallVector<Value, 4> lbs, ubs, steps;
+  Value zero = b.create<ConstantIndexOp>(0);
+  Value one = b.create<ConstantIndexOp>(1);
 
   // 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;
-    Value zero = std_constant_index(0);
-    Value one = std_constant_index(1);
     lbs.resize(extraLoops, zero);
     ubs.resize(extraLoops, one);
     steps.resize(extraLoops, one);
   }
 
   // Add existing bounds.
-  lbs.append(bounds.getLbs().begin(), bounds.getLbs().end());
-  ubs.append(bounds.getUbs().begin(), bounds.getUbs().end());
-
-  // Emit constant operations for steps.
+  lbs.append(rank, zero);
+  ubs.reserve(lbs.size());
   steps.reserve(lbs.size());
-  llvm::transform(bounds.getSteps(), std::back_inserter(steps),
-                  [](int64_t step) { return std_constant_index(step); });
+  for (auto idx = 0; idx < rank; ++idx) {
+    ubs.push_back(
+        b.createOrFold<memref::DimOp>(from, b.create<ConstantIndexOp>(idx)));
+    steps.push_back(one);
+  }
 
   // Obtain thread identifiers and block sizes, necessary to map to them.
   auto indexType = b.getIndexType();
   SmallVector<Value, 3> threadIds, blockDims;
   for (unsigned i = 0; i < 3; ++i) {
     auto dimName = b.getStringAttr(getDimName(i));
-    threadIds.push_back(b.create<gpu::ThreadIdOp>(loc, indexType, dimName));
-    blockDims.push_back(b.create<gpu::BlockDimOp>(loc, indexType, dimName));
+    threadIds.push_back(b.create<gpu::ThreadIdOp>(indexType, dimName));
+    blockDims.push_back(b.create<gpu::BlockDimOp>(indexType, dimName));
   }
 
   // Produce the loop nest with copies.
   SmallVector<Value, 8> ivs(lbs.size());
   mlir::scf::buildLoopNest(
-      b, loc, lbs, ubs, steps,
+      b, b.getLoc(), lbs, ubs, steps,
       [&](OpBuilder &b, Location loc, ValueRange loopIvs) {
         ivs.assign(loopIvs.begin(), loopIvs.end());
         auto activeIvs = llvm::makeArrayRef(ivs).take_back(rank);
         Value loaded = b.create<memref::LoadOp>(loc, from, activeIvs);
         b.create<memref::StoreOp>(loc, loaded, to, activeIvs);
       });
 
   // Map the innermost loops to threads in reverse order.
static void insertCopies(Region &region, Location loc, Value from, Value to) {
   auto toType = to.getType().cast<MemRefType>();
   (void)fromType;
   (void)toType;
   assert(fromType.getShape() == toType.getShape());
   assert(fromType.getRank() != 0);
   assert(llvm::hasSingleElement(region) &&
          "unstructured control flow not supported");
 
-  OpBuilder b(region.getContext());
-  b.setInsertionPointToStart(&region.front());
-
-  ScopedContext edscContext(b, loc);
-  MemRefBoundsCapture fromBoundsCapture(from);
-  insertCopyLoops(b, loc, fromBoundsCapture, from, to);
-  b.create<gpu::BarrierOp>(loc);
+  auto b = ImplicitLocOpBuilder::atBlockBegin(loc, &region.front());
+  insertCopyLoops(b, from, to);
+  b.create<gpu::BarrierOp>();
 
   b.setInsertionPoint(&region.front().back());
-  b.create<gpu::BarrierOp>(loc);
-  insertCopyLoops(b, loc, fromBoundsCapture, to, from);
+  b.create<gpu::BarrierOp>();
+  insertCopyLoops(b, 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/Transforms/Fusion.cpp

 #include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.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/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/MemRef/EDSC/Intrinsics.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
for (auto en : llvm::enumerate(op.getShapedOperands())) {
     }
   }
   llvm_unreachable("Expect to be able to extract a shape defining loop range");
 }
 
 /// Fuses the producer by cloning the `producer`. The `fusedLoopsAndRanges`
 /// provides the loop range information for the fused loops. The rest are
 /// obtained from the producer itself, since they are not tiled + fused.
-static LinalgOp fuse(OpBuilder &builder, LinalgOp producer,
+static LinalgOp fuse(OpBuilder &b, LinalgOp producer,
                      const DenseMap<unsigned, Range> &fusedLoopsAndRanges) {
   SmallVector<Value, 8> ivs, tileSizes, sizeBounds;
   SmallVector<Range, 8> loopRanges;
-  auto zero = std_constant_index(0);
-  auto one = std_constant_index(1);
   Location loc = producer.getLoc();
+  auto zero = b.create<ConstantIndexOp>(loc, 0);
+  auto one = b.create<ConstantIndexOp>(loc, 1);
 
   for (unsigned i = 0, e = producer.getNumLoops(); i < e; ++i) {
     auto it = fusedLoopsAndRanges.find(i);
     if (it != fusedLoopsAndRanges.end()) {
       ivs.push_back(it->second.offset);
       tileSizes.push_back(it->second.size);
       sizeBounds.push_back(nullptr);
       loopRanges.push_back(it->second);
       LLVM_DEBUG(llvm::dbgs() << "tiled loop#" << i << " with LoopRange "
                               << loopRanges.back() << "\n");
     } else {
       auto shapeDim = getShapeDefiningLoopRange(producer, i);
-      Value dim = memref_dim(shapeDim.shape, shapeDim.dimension);
+      Value dim = b.createOrFold<memref::DimOp>(loc, shapeDim.shape,
+                                                shapeDim.dimension);
       tileSizes.push_back(zero);
       sizeBounds.push_back(dim);
       loopRanges.push_back(Range{zero, dim, one});
       LLVM_DEBUG(llvm::dbgs() << "full loop#" << i << " with LoopRange "
                               << loopRanges.back() << "\n");
     }
   }
 
   SmallVector<Value, 8> clonedShapes;
   clonedShapes.reserve(producer.getNumShapedOperands());
 
   // Compute subranges for all tensor input/output operands.
   auto tiledOperands = llvm::to_vector<4>(producer.getShapedOperands());
-  clonedShapes.append(makeTiledShapes(builder, loc, producer, tiledOperands,
-                                      ivs, tileSizes, sizeBounds));
+  clonedShapes.append(makeTiledShapes(b, loc, producer, tiledOperands, ivs,
+                                      tileSizes, sizeBounds));
 
   // Append the other operands.
   auto operands = producer.getAssumedNonShapedOperands();
   clonedShapes.append(operands.begin(), operands.end());
 
   // Iterate over the results in order.
   // Extract the subtensor type from the linearized range.
   // Since we do not enforce any canonicalizations on the fly, this is always
   // fully dynamic at construction time.
   SmallVector<Type, 4> resultTypes;
   resultTypes.reserve(producer->getNumResults());
   for (RankedTensorType t : producer.getOutputTensorTypes()) {
     unsigned rank = t.getRank();
     SmallVector<int64_t, 4> staticOffsetsVector(
         rank, ShapedType::kDynamicStrideOrOffset);
     SmallVector<int64_t, 4> staticSizesVector(rank, ShapedType::kDynamicSize);
     SmallVector<int64_t, 4> staticStridesVector(
         rank, ShapedType::kDynamicStrideOrOffset);
     resultTypes.push_back(SubTensorOp::inferResultType(
         t.cast<RankedTensorType>(), staticOffsetsVector, staticSizesVector,
         staticStridesVector));
   }
 
-  Operation *clonedOp = producer.clone(builder, loc, resultTypes, clonedShapes);
+  Operation *clonedOp = producer.clone(b, loc, resultTypes, clonedShapes);
   // When the producer has index semantics, we have to transform the indices of
   // the producer according to the tiling of the consumer, i.e. offset them by
   // the values computed in `loopRanges`.
   assert(!isa<IndexedGenericOp>(producer) && "unexpected op");
   if (producer.hasIndexSemantics()) {
     assert(clonedOp->getNumRegions() == 1 &&
            clonedOp->getRegion(0).getBlocks().size() == 1 &&
            "expected producer to have one block.");
     // Shift all indices by the tile offset.
     Block &block = clonedOp->getRegion(0).front();
     for (IndexOp indexOp : block.getOps<IndexOp>()) {
-      OpBuilder::InsertionGuard g(builder);
-      builder.setInsertionPointAfter(indexOp);
+      OpBuilder::InsertionGuard g(b);
+      b.setInsertionPointAfter(indexOp);
       AffineExpr index, offset;
-      bindDims(builder.getContext(), index, offset);
-      AffineApplyOp applyOp = builder.create<AffineApplyOp>(
+      bindDims(b.getContext(), index, offset);
+      AffineApplyOp applyOp = b.create<AffineApplyOp>(
           indexOp.getLoc(), index + offset,
           ValueRange{indexOp.getResult(), loopRanges[indexOp.dim()].offset});
       indexOp.getResult().replaceAllUsesExcept(applyOp, applyOp);
     }
   }
 
   return clonedOp;
 }
for (AffineMap map2 :
       }
     }
   }
   return fusableDependences;
 }
 
 /// Tile the fused loops in the root operation, by setting the tile sizes for
 /// all other loops to zero (those will be tiled later).
-static Optional<TiledLinalgOp> tileRootOperation(
-    OpBuilder &builder, LinalgOp op, ArrayRef<Value> tileSizeVector,
-    const LinalgTilingOptions &options, const std::set<unsigned> &fusedLoops) {
+static Optional<TiledLinalgOp>
+tileRootOperation(OpBuilder &b, LinalgOp op, ArrayRef<Value> tileSizeVector,
+                  const LinalgTilingOptions &options,
+                  const std::set<unsigned> &fusedLoops) {
   SmallVector<Value, 4> tileSizes(tileSizeVector.begin(), tileSizeVector.end());
-  auto zero = std_constant_index(0);
+  auto zero = b.create<ConstantIndexOp>(op.getLoc(), 0);
   for (unsigned i = 0, e = tileSizes.size(); i != e; ++i)
     if (!fusedLoops.count(i))
       tileSizes[i] = zero;
   LinalgTilingOptions tileFusedLoopsOptions = options;
   tileFusedLoopsOptions.setTileSizes(tileSizes);
-  return tileLinalgOp(builder, op, tileFusedLoopsOptions);
+  return tileLinalgOp(b, op, tileFusedLoopsOptions);
 }
 
 /// Fuse the operations in `fusionCandidates` with `tiledOp`. Latter is expected
 /// to be a tiled operation such that it is valid to fuse all operations in
 /// `fusionCandidates`, i.e. move the operation within the inter-tile loops of
 /// `tiledOp`.
 static SmallVector<LinalgOp, 1>
-fuseOperations(OpBuilder &builder, LinalgOp rootOp, TiledLinalgOp tiledLinalgOp,
+fuseOperations(OpBuilder &b, LinalgOp rootOp, TiledLinalgOp tiledLinalgOp,
                ArrayRef<LinalgOp> fusionCandidates,
                const FusableOpDependencesTy &fusableDependences,
                const std::set<unsigned> &fusedLoops) {
   LinalgOp tiledOp = tiledLinalgOp.op;
-  OpBuilder::InsertionGuard guard(builder);
-  builder.setInsertionPoint(tiledOp);
+  OpBuilder::InsertionGuard guard(b);
+  b.setInsertionPoint(tiledOp);
 
   DenseMap<unsigned, Range> fusedLoopsAndRanges;
   for (unsigned loop : fusedLoops) {
     ShapeDimension shapeDim = getShapeDefiningLoopRange(tiledOp, loop, true);
     fusedLoopsAndRanges[loop] = getRangeFromOperandShape(
-        builder, tiledOp.getLoc(), shapeDim.shape, shapeDim.dimension);
+        b, tiledOp.getLoc(), shapeDim.shape, shapeDim.dimension);
   }
 
   SmallVector<LinalgOp, 1> fusedOps(fusionCandidates.size());
   DenseMap<Operation *, LinalgOp> origOpToFusedOp;
   origOpToFusedOp[rootOp.getOperation()] = tiledOp;
   for (auto candidate : enumerate(llvm::reverse(fusionCandidates))) {
     LinalgOp origOp = candidate.value();
-    LinalgOp fusedOp = fuse(builder, origOp, fusedLoopsAndRanges);
+    LinalgOp fusedOp = fuse(b, origOp, fusedLoopsAndRanges);
     origOpToFusedOp[origOp.getOperation()] = fusedOp;
     fusedOps[fusionCandidates.size() - candidate.index() - 1] = fusedOp;
 
-    // Prepare the builder for the next insertion point.
-    auto guard =
-        llvm::make_scope_exit([&]() { builder.setInsertionPoint(fusedOp); });
+    // Prepare the b for the next insertion point.
+    auto guard = llvm::make_scope_exit([&]() { b.setInsertionPoint(fusedOp); });
     if (!origOp.hasTensorSemantics())
       continue;
 
     // If the producer consumer operations are linalg operations on tensors, the
     // dependence is due to value produced (as a return tensor) by the producer
     // and used in the consumer. The returned value of the fused op needs to be
     // made the operand of the tiled/fused consumer operation. By construction
     // the value returned by the producer is the value used by the consumer.
for (auto &operand :
         if (opResult.getOwner() == origOp)
           operand.set(origOp.getOutputTensors()[opResult.getResultNumber()]);
   }
   return fusedOps;
 }
 
 template <typename LoopType>
 static Optional<TiledAndFusedLinalgOps>
-tileAndFuseLinalgOpsImpl(OpBuilder &builder, ArrayRef<LinalgOp> ops,
+tileAndFuseLinalgOpsImpl(OpBuilder &b, ArrayRef<LinalgOp> ops,
                          const LinalgDependenceGraph &dependenceGraph,
                          const LinalgTilingOptions &tilingOptions) {
   if (ops.size() < 2)
     return llvm::None;
   LinalgOp rootOp = ops.back();
   if (!llvm::all_of(
           ops,
           [](LinalgOp linalgOp) { return linalgOp.hasBufferSemantics(); }) &&
       !llvm::all_of(ops, [](LinalgOp linalgOp) {
         return linalgOp.hasTensorSemantics();
       })) {
     rootOp.emitError(
         "unable to fuse operations that have tensor semantics with operations "
         "that have buffer semantics and viceversa.");
     return llvm::None;
   }
   // TODO: Support interchange with tile + fuse. This might actually help do
   // better fusion.
   if (!tilingOptions.interchangeVector.empty()) {
     rootOp.emitRemark("unable to handle tile and fuse with interchange");
     return llvm::None;
   }
 
-  OpBuilder::InsertionGuard guard(builder);
-  builder.setInsertionPoint(rootOp);
-  ScopedContext scope(builder, rootOp.getLoc());
+  OpBuilder::InsertionGuard guard(b);
+  b.setInsertionPoint(rootOp);
+  ScopedContext scope(b, rootOp.getLoc());
 
   // Find all the producers.
   LLVM_DEBUG(llvm::dbgs() << "findAllFusableDependences\n");
   FusableOpDependencesTy fusableDependences =
       findAllFusableDependences(ops, dependenceGraph);
   if (fusableDependences.empty()) {
     LLVM_DEBUG(llvm::dbgs() << "no fusable dependencies found\n");
     return llvm::None;
   }
 
   TiledAndFusedLinalgOps ret;
   // Find the loops that can be tiled and fused.
   LLVM_DEBUG(llvm::dbgs() << "collectFusableLoops\n");
   ret.fusedLoopDims = collectFusableLoops(ops, fusableDependences);
 
   // If there are no fusable dependences or there are no tile+fusable loops,
   // just return.
   if (ret.fusedLoopDims.empty()) {
     LLVM_DEBUG(llvm::dbgs() << "no fusable loops found\n");
     return llvm::None;
   }
 
   // Tile the fused loops in the last operation in the list.
   SmallVector<Value, 4> tileSizeVector =
-      tilingOptions.tileSizeComputationFunction(builder, rootOp);
+      tilingOptions.tileSizeComputationFunction(b, rootOp);
   Optional<TiledLinalgOp> tiledRootOp = tileRootOperation(
-      builder, rootOp, tileSizeVector, tilingOptions, ret.fusedLoopDims);
+      b, rootOp, tileSizeVector, tilingOptions, ret.fusedLoopDims);
   if (!tiledRootOp) {
     rootOp.emitRemark("failed to tile the fused loops");
     return llvm::None;
   }
   ret.op = tiledRootOp->op;
   ret.fusedLoops.assign(tiledRootOp->loops.begin(), tiledRootOp->loops.end());
 
   // Fuse the other operations into the fused inter-tile loops produced above.
-  ret.fusedProducers =
-      fuseOperations(builder, rootOp, *tiledRootOp, ops.drop_back(),
+  ret.fusedProducers = fuseOperations(b, rootOp, *tiledRootOp, ops.drop_back(),
                                       fusableDependences, ret.fusedLoopDims);
 
   return ret;
 }
 
 Optional<TiledAndFusedLinalgOps>
-mlir::linalg::tileAndFuseLinalgOps(OpBuilder &builder, ArrayRef<LinalgOp> ops,
+mlir::linalg::tileAndFuseLinalgOps(OpBuilder &b, ArrayRef<LinalgOp> ops,
                                    const LinalgDependenceGraph &dependenceGraph,
                                    const LinalgTilingOptions &tilingOptions) {
   switch (tilingOptions.loopType) {
   case LinalgTilingLoopType::Loops:
-    return tileAndFuseLinalgOpsImpl<scf::ForOp>(builder, ops, dependenceGraph,
+    return tileAndFuseLinalgOpsImpl<scf::ForOp>(b, ops, dependenceGraph,
                                                 tilingOptions);
   case LinalgTilingLoopType::ParallelLoops:
-    return tileAndFuseLinalgOpsImpl<scf::ParallelOp>(
-        builder, ops, dependenceGraph, tilingOptions);
+    return tileAndFuseLinalgOpsImpl<scf::ParallelOp>(b, ops, dependenceGraph,
+                                                     tilingOptions);
   default:;
   }
   return llvm::None;
 }

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

 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/IR/LinalgTypes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/MemRef/EDSC/Intrinsics.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
if (isZero(tileSizes[idx - zerosCount])) {
       continue;
     }
     loopIndexToRangeIndex[idx] = idx - zerosCount;
   }
 
   // Create a new range with the applied tile sizes.
   SmallVector<Range, 4> res;
   for (unsigned idx = 0, e = tileSizes.size(); idx < e; ++idx)
-    res.push_back(
-        Range{std_constant_index(0), shapeSizes[idx], tileSizes[idx]});
+    res.push_back(Range{b.create<ConstantIndexOp>(loc, 0), shapeSizes[idx],
+                        tileSizes[idx]});
   return std::make_tuple(res, loopIndexToRangeIndex);
 }
 
 // All indices returned by IndexOp should be invariant with respect to tiling.
 // Therefore, if an operation is tiled, we have to transform the indices
 // accordingly, i.e. offset them by the values of the corresponding induction
 // variables that are captured implicitly in the body of the op.
 //
Optional<TiledLinalgOp> static tileLinalgOpImpl(
 
   // Enforce the convention that "tiling by zero" skips tiling a particular
   // dimension. This convention is significantly simpler to handle instead of
   // adjusting affine maps to account for missing dimensions.
   auto nLoops = op.getNumLoops();
   SmallVector<Value, 4> tileSizeVector =
       options.tileSizeComputationFunction(b, op);
   if (tileSizeVector.size() < nLoops) {
-    auto zero = std_constant_index(0);
+    auto zero = b.create<ConstantIndexOp>(op.getLoc(), 0);
     tileSizeVector.append(nLoops - tileSizeVector.size(), zero);
   }
 
   return tileLinalgOpImpl<LoopTy>(b, op, tileSizeVector, options);
 }
 
 Optional<TiledLinalgOp>
 mlir::linalg::tileLinalgOp(OpBuilder &b, LinalgOp op,

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

SmallVector<Value, 4> makeTiledShapes(OpBuilder &b, Location loc,
   using namespace edsc::op;
 
   // Construct (potentially temporary) mins and maxes on which to apply maps
   // that define tile subshapes.
   SmallVector<Value, 8> lbs, subShapeSizes;
   for (unsigned idx = 0, idxIvs = 0, e = tileSizes.size(); idx < e; ++idx) {
     LLVM_DEBUG(llvm::dbgs() << "makeTiledShapes: for loop#" << idx << "\n");
     bool isTiled = !isZero(tileSizes[idx]);
-    lbs.push_back(isTiled ? ivs[idxIvs++] : (Value)std_constant_index(0));
+    lbs.push_back(isTiled ? ivs[idxIvs++]
+                          : (Value)b.create<ConstantIndexOp>(loc, 0));
     // Before composing, we need to make range a closed interval.
     Value size = isTiled ? tileSizes[idx] : sizeBounds[idx];
-    subShapeSizes.push_back(size - std_constant_index(1));
+    subShapeSizes.push_back(size - b.create<ConstantIndexOp>(loc, 1));
     LLVM_DEBUG(llvm::dbgs() << "lb: " << lbs.back() << "\n");
     LLVM_DEBUG(llvm::dbgs() << "size: " << subShapeSizes.back() << "\n");
   }
 
   MLIRContext *context = b.getContext();
   SmallVector<Value, 4> tiledShapes;
   tiledShapes.reserve(tiledOperands.size());
   for (auto en : llvm::enumerate(tiledOperands)) {
for (auto en : llvm::enumerate(tiledOperands)) {
     SmallVector<OpFoldResult, 4> offsets, sizes, strides;
     offsets.reserve(rank);
     sizes.reserve(rank);
     strides.reserve(rank);
     for (unsigned r = 0; r < rank; ++r) {
       LLVM_DEBUG(llvm::dbgs() << "makeTiledShapes: for dim#" << r);
       if (!isTiled(map.getSubMap({r}), tileSizes)) {
         offsets.push_back(b.getIndexAttr(0));
-        Value dim = memref_dim(shapedOp, r).value;
+        Value dim = b.createOrFold<memref::DimOp>(loc, shapedOp, r);
         sizes.push_back(dim);
         strides.push_back(b.getIndexAttr(1));
         LLVM_DEBUG(llvm::dbgs() << ": not tiled: use size: " << dim << "\n");
         continue;
       }
       LLVM_DEBUG(llvm::dbgs() << ": tiled: figure out subsize...\n");
 
       // Tiling creates a new slice at the proper index, the slice step is 1
       // (i.e. the op does not subsample, stepping occurs in the loop).
       auto m = map.getSubMap({r});
       LLVM_DEBUG(llvm::dbgs() << "makeTiledShapes: submap: " << map << "\n");
       auto offset = applyMapToValues(b, loc, m, lbs).front();
       offsets.push_back(offset);
       auto closedIntSize = applyMapToValues(b, loc, m, subShapeSizes).front();
       // Resulting size needs to be made half open interval again.
-      auto size = closedIntSize + std_constant_index(1);
+      auto size = closedIntSize + b.create<ConstantIndexOp>(loc, 1);
       LLVM_DEBUG(llvm::dbgs() << "makeTiledShapes: raw size: " << size << "\n");
 
       // The size of the subview / subtensor should be trimmed to avoid
       // out-of-bounds accesses, unless we statically know the subshape size
       // divides the shape size evenly.
       int64_t shapeSize = shapedType.getDimSize(r);
       auto sizeCst = size.getDefiningOp<ConstantIndexOp>();
       if (ShapedType::isDynamic(shapeSize) || !sizeCst ||