[MLIR] Create memref dialect and move several dialect-specific ops from std.

[dfki-jugr]

Summary

Create the memref dialect and move several dialect-specific ops without
dependencies to other ops from std dialect to this dialect.
Note: The ops haven't been removed from std dialect yet.

The roadmap to split the memref dialect from std is discussed here:
https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667

[mehdi_amini]

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

78

Could/should it be a method on the CastOp instead?

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

This introduces duplicated code in the repository, most of this is actually "moved" conceptually. Could we actually move the code and avoid duplication?

[rriddle]

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

78

+1

mlir/include/mlir/Dialect/MemRef/IR/MemRefBase.td

23

Drop the newline before and after this paragraph.

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

+1

[silvas]

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

+1

[silvas]

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

Personally I found that the cleanups involved in moving the ops were actually most of the work. Just copying the ops first gives a false impression that the work has been done.

[dfki-jugr]

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

78

The method uses a CastOp?
Or do you mean a different one?

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

The idea was to split the moving process into two steps: first adding the ops and second remove them from std. This should reduce review overhead, since it leads to a huge CL, otherwise. But sure, to avoid code duplication, it makes sense to have it in one step.

[ftynse]

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

882

Phabricator highlights the code that was moved, and so do most git clients, so it is actually easier for reviewers and even the authors to do the change in one commit. For example, I would likely ignore the code that was just moved between files in the review, but would complain about things that appear as new code, asking the author to change them even if they didn't write them.

[mehdi_amini]

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

78

I mean that instead of a free function: bool canFoldIntoConsumerOp(CastOp castOp);

It seems like this could better be a predicate as a method on the class itself: bool CastOp::canFoldIntoConsumerOp() { ... }

[dfki-jugr]

Removed corresponding ops in std dialect and adapted test cases.
Addressed comments.

[mehdi_amini]

thanks!

[silvas]

mlir/test/IR/core-ops.mlir

549–550

please move all uses of the memref dialect in mlir/test/IR to their own proper locations inside test/Dialect/MemRef. See what I did for the tensor dialect for examples.

[silvas]

mlir/test/IR/core-ops.mlir

549–550

Actually, looks like we have accumulated some technical debt here. Looks like some of these tests need to be moved too. E.g. test/IR/slice.mlir looks like it needs to move to linalg or something, and a lot of the code in parser.mlir needs to be moved to somewhere in the affine dialect tests.

But it looks like memory-ops.mlir, invalid-ops.mlir, and core-ops.mlir changes make sense to move into test/Dialect/MemRef

(given this complexity, seems like a separate patch might be better; please make sure to do that follow-up though)

[herhut]

+1 to landing and then cleaning up tests.

[ftynse]

It also broke integration tests https://buildkite.com/mlir/mlir-core/builds/11667

mlir/docs/BufferDeallocationInternals.md

 * There are no users/aliases of the target value between the defining operation
 of the source value and the copy operation.
 * There are no users/aliases of the source value between the copy operation and
 the deallocation of the source value.
 
 ## Known Limitations
 
 BufferDeallocation introduces additional copies using allocations from the
-“std” dialect (“std.alloc”). Analogous, all deallocations use the “std”
-dialect-free operation “std.dealloc”. The actual copy process is realized using
-“linalg.copy”. Furthermore, buffers are essentially immutable after their
-creation in a block. Another limitations are known in the case using
-unstructered control flow.
+“memref” dialect (“memref.alloc”). Analogous, all deallocations use the
+“memref” dialect-free operation “memref.dealloc”. The actual copy process is
+realized using “linalg.copy”. Furthermore, buffers are essentially immutable
+after their creation in a block. Another limitations are known in the case
+using unstructered control flow.

mlir/docs/Dialects/Linalg.md

 ```mlir
 // Run: mlir-opt example4.mlir -convert-linalg-to-std
 // Note that we lower the Linalg dialect directly to the Standard dialect.
 // See this doc: https://mlir.llvm.org/docs/Dialects/Standard/
 
 #map0 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 
 func @example(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
-  %0 = memref_cast %arg0 : memref<?x?xf32> to memref<?x?xf32, #map0>
-  %1 = memref_cast %arg1 : memref<?x?xf32> to memref<?x?xf32, #map0>
-  %2 = memref_cast %arg2 : memref<?x?xf32> to memref<?x?xf32, #map0>
+  %0 = memref.cast %arg0 : memref<?x?xf32> to memref<?x?xf32, #map0>
+  %1 = memref.cast %arg1 : memref<?x?xf32> to memref<?x?xf32, #map0>
+  %2 = memref.cast %arg2 : memref<?x?xf32> to memref<?x?xf32, #map0>
   call @pointwise_add(%0, %1, %2) : (memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) -> ()
   return
 }
 func @pointwise_add(memref<?x?xf32, #map0>, memref<?x?xf32, #map0>, memref<?x?xf32, #map0>) attributes {llvm.emit_c_interface}
 ```
 
 Which, after lowering to LLVM resembles:
 

 
 ### Metadata Ops<a name="metadata_ops"></a>
 
 A set of ops that manipulate metadata but do not move memory. These ops take
 `view` operands + extra attributes and return new `view`s. The returned `view`s
 generally alias the operand `view`. At the moment the existing ops are:
 
 ```
-* `std.view`,
+* `memref.view`,
 * `std.subview`,
-* `std.transpose`.
+* `memref.transpose`.
 * `linalg.range`,
 * `linalg.slice`,
 * `linalg.reshape`,
 ```
 
 Future ops are added on a per-need basis but should include:
 
 ```

mlir/docs/Traits.md

 
 ### AutomaticAllocationScope
 
 *   `OpTrait::AutomaticAllocationScope` -- `AutomaticAllocationScope`
 
 This trait is carried by region holding operations that define a new scope for
 automatic allocation. Such allocations are automatically freed when control is
 transferred back from the regions of such operations. As an example, allocations
-performed by [`std.alloca`](Dialects/Standard.md#stdalloca-allocaop) are
+performed by [`memref.alloca`](Dialects/Standard.md#stdalloca-allocaop) are
 automatically freed when control leaves the region of its closest surrounding op
 that has the trait AutomaticAllocationScope.
 
 ### Broadcastable
 
 *   `OpTrait::ResultsBroadcastableShape` -- `ResultsBroadcastableShape`
 
 This trait adds the property that the operation is known to have

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

 // have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/Sequence.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns
 //===----------------------------------------------------------------------===//
 
 /// Convert the given TensorType into the corresponding MemRefType.
 static MemRefType convertTensorToMemRef(TensorType type) {
   assert(type.hasRank() && "expected only ranked shapes");
   return MemRefType::get(type.getShape(), type.getElementType());
 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
-  auto alloc = rewriter.create<AllocOp>(loc, type);
+  auto alloc = rewriter.create<memref::AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
   auto *parentBlock = alloc->getBlock();
   alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
-  auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
+  auto dealloc = rewriter.create<memref::DeallocOp>(loc, alloc);
   dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // We will be generating constant indices up-to the largest dimension.
     // Create these constants up-front to avoid large amounts of redundant
     // operations.
     auto valueShape = memRefType.getShape();
     SmallVector<Value, 8> constantIndices;
 
     if (!valueShape.empty()) {
       for (auto i : llvm::seq<int64_t>(
                0, *std::max_element(valueShape.begin(), valueShape.end())))
         constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, i));
     } else {
       // This is the case of a tensor of rank 0.
       constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, 0));
     }
 
     // The constant operation represents a multi-dimensional constant, so we
     // will need to generate a store for each of the elements. The following
     // functor recursively walks the dimensions of the constant shape,
void ToyToAffineLoweringPass::runOnFunction() {
 
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine` and `Standard` dialects.
-  target.addLegalDialect<AffineDialect, StandardOpsDialect>();
+  target.addLegalDialect<AffineDialect, memref::MemRefDialect,
+                         StandardOpsDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addLegalOp<toy::PrintOp>();
 

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

 // have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/Sequence.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns
 //===----------------------------------------------------------------------===//
 
 /// Convert the given TensorType into the corresponding MemRefType.
 static MemRefType convertTensorToMemRef(TensorType type) {
   assert(type.hasRank() && "expected only ranked shapes");
   return MemRefType::get(type.getShape(), type.getElementType());
 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
-  auto alloc = rewriter.create<AllocOp>(loc, type);
+  auto alloc = rewriter.create<memref::AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
   auto *parentBlock = alloc->getBlock();
   alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
-  auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
+  auto dealloc = rewriter.create<memref::DeallocOp>(loc, alloc);
   dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // We will be generating constant indices up-to the largest dimension.
     // Create these constants up-front to avoid large amounts of redundant
     // operations.
     auto valueShape = memRefType.getShape();
     SmallVector<Value, 8> constantIndices;
 
     if (!valueShape.empty()) {
       for (auto i : llvm::seq<int64_t>(
                0, *std::max_element(valueShape.begin(), valueShape.end())))
         constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, i));
     } else {
       // This is the case of a tensor of rank 0.
       constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, 0));
     }
     // The constant operation represents a multi-dimensional constant, so we
     // will need to generate a store for each of the elements. The following
     // functor recursively walks the dimensions of the constant shape,
     // generating a store when the recursion hits the base case.
void ToyToAffineLoweringPass::runOnFunction() {
 
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine` and `Standard` dialects.
-  target.addLegalDialect<AffineDialect, StandardOpsDialect>();
+  target.addLegalDialect<AffineDialect, memref::MemRefDialect,
+                         StandardOpsDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addLegalOp<toy::PrintOp>();
 

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

 // have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/Sequence.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns
 //===----------------------------------------------------------------------===//
 
 /// Convert the given TensorType into the corresponding MemRefType.
 static MemRefType convertTensorToMemRef(TensorType type) {
   assert(type.hasRank() && "expected only ranked shapes");
   return MemRefType::get(type.getShape(), type.getElementType());
 }
 
 /// Insert an allocation and deallocation for the given MemRefType.
 static Value insertAllocAndDealloc(MemRefType type, Location loc,
                                    PatternRewriter &rewriter) {
-  auto alloc = rewriter.create<AllocOp>(loc, type);
+  auto alloc = rewriter.create<memref::AllocOp>(loc, type);
 
   // Make sure to allocate at the beginning of the block.
   auto *parentBlock = alloc->getBlock();
   alloc->moveBefore(&parentBlock->front());
 
   // Make sure to deallocate this alloc at the end of the block. This is fine
   // as toy functions have no control flow.
-  auto dealloc = rewriter.create<DeallocOp>(loc, alloc);
+  auto dealloc = rewriter.create<memref::DeallocOp>(loc, alloc);
   dealloc->moveBefore(&parentBlock->back());
   return alloc;
 }
 
 /// This defines the function type used to process an iteration of a lowered
 /// loop. It takes as input an OpBuilder, an range of memRefOperands
 /// corresponding to the operands of the input operation, and the range of loop
 /// induction variables for the iteration. It returns a value to store at the
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // We will be generating constant indices up-to the largest dimension.
     // Create these constants up-front to avoid large amounts of redundant
     // operations.
     auto valueShape = memRefType.getShape();
     SmallVector<Value, 8> constantIndices;
 
     if (!valueShape.empty()) {
       for (auto i : llvm::seq<int64_t>(
                0, *std::max_element(valueShape.begin(), valueShape.end())))
         constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, i));
     } else {
       // This is the case of a tensor of rank 0.
       constantIndices.push_back(rewriter.create<ConstantIndexOp>(loc, 0));
     }
 
     // The constant operation represents a multi-dimensional constant, so we
     // will need to generate a store for each of the elements. The following
     // functor recursively walks the dimensions of the constant shape,
void ToyToAffineLoweringPass::runOnFunction() {
 
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine` and `Standard` dialects.
-  target.addLegalDialect<AffineDialect, StandardOpsDialect>();
+  target.addLegalDialect<AffineDialect, memref::MemRefDialect,
+                         StandardOpsDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addLegalOp<toy::PrintOp>();
 

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

 /// conversion patterns capture the LLVMTypeConverter and the LowerToLLVMOptions
 /// by reference meaning the references have to remain alive during the entire
 /// pattern lifetime.
 void populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                          OwningRewritePatternList &patterns);
 
 /// Creates a pass to convert the Standard dialect into the LLVMIR dialect.
 /// stdlib malloc/free is used by default for allocating memrefs allocated with
-/// std.alloc, while LLVM's alloca is used for those allocated with std.alloca.
+/// memref.alloc, while LLVM's alloca is used for those allocated with
+/// memref.alloca.
 std::unique_ptr<OperationPass<ModuleOp>>
 createLowerToLLVMPass(const LowerToLLVMOptions &options =
                           LowerToLLVMOptions::getDefaultOptions());
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_

mlir/include/mlir/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(Async)
 add_subdirectory(ArmNeon)
 add_subdirectory(ArmSVE)
 add_subdirectory(AVX512)
 add_subdirectory(Complex)
 add_subdirectory(GPU)
 add_subdirectory(Math)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
+add_subdirectory(MemRef)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)
 add_subdirectory(PDLInterp)
 add_subdirectory(Quant)
 add_subdirectory(SCF)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(Tensor)
 add_subdirectory(Tosa)
 add_subdirectory(Vector)

mlir/include/mlir/Dialect/GPU/GPUOps.td

 def GPU_AllocOp : GPU_Op<"alloc", [
     GPU_AsyncOpInterface,
     AttrSizedOperandSegments
   ]> {
 
   let summary = "GPU memory allocation operation.";
   let description = [{
     The `gpu.alloc` operation allocates a region of memory on the GPU. It is
-    similar to the `std.alloc` op, but supports asynchronous GPU execution.
+    similar to the `memref.alloc` op, but supports asynchronous GPU execution.
 
     The op does not execute before all async dependencies have finished
     executing.
 
     If the `async` keyword is present, the op is executed asynchronously (i.e.
     it does not block until the execution has finished on the device). In
     that case, it also returns a !gpu.async.token.
 

 
 def GPU_DeallocOp : GPU_Op<"dealloc", [GPU_AsyncOpInterface]> {
 
   let summary = "GPU memory deallocation operation";
 
   let description = [{
     The `gpu.dealloc` operation frees the region of memory referenced by a
     memref which was originally created by the `gpu.alloc` operation. It is
-    similar to the `std.dealloc` op, but supports asynchronous GPU execution.
+    similar to the `memref.dealloc` op, but supports asynchronous GPU execution.
 
     The op does not execute before all async dependencies have finished
     executing.
 
     If the `async` keyword is present, the op is executed asynchronously (i.e.
     it does not block until the execution has finished on the device). In
     that case, it returns a !gpu.async.token.
 

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

value = folder ? folder->create<Op>(ScopedContext::getBuilderRef(),
                          ScopedContext::getLocation(), args...);
   }
 
   operator Value() { return value; }
   Value value;
 };
 
 using folded_math_tanh = FoldedValueBuilder<math::TanhOp>;
+using folded_memref_alloc = FoldedValueBuilder<memref::AllocOp>;
+using folded_memref_cast = FoldedValueBuilder<memref::CastOp>;
+using folded_memref_view = FoldedValueBuilder<memref::ViewOp>;
 using folded_std_constant_index = FoldedValueBuilder<ConstantIndexOp>;
 using folded_std_constant_float = FoldedValueBuilder<ConstantFloatOp>;
 using folded_std_constant_int = FoldedValueBuilder<ConstantIntOp>;
 using folded_std_constant = FoldedValueBuilder<ConstantOp>;
 using folded_std_dim = FoldedValueBuilder<DimOp>;
 using folded_std_muli = FoldedValueBuilder<MulIOp>;
 using folded_std_addi = FoldedValueBuilder<AddIOp>;
 using folded_std_addf = FoldedValueBuilder<AddFOp>;
-using folded_std_alloc = FoldedValueBuilder<AllocOp>;
 using folded_std_constant = FoldedValueBuilder<ConstantOp>;
 using folded_std_constant_float = FoldedValueBuilder<ConstantFloatOp>;
 using folded_std_constant_index = FoldedValueBuilder<ConstantIndexOp>;
 using folded_std_constant_int = FoldedValueBuilder<ConstantIntOp>;
 using folded_std_dim = FoldedValueBuilder<DimOp>;
 using folded_std_index_cast = FoldedValueBuilder<IndexCastOp>;
 using folded_std_muli = FoldedValueBuilder<MulIOp>;
 using folded_std_mulf = FoldedValueBuilder<MulFOp>;
-using folded_std_memref_cast = FoldedValueBuilder<MemRefCastOp>;
 using folded_std_select = FoldedValueBuilder<SelectOp>;
 using folded_std_load = FoldedValueBuilder<LoadOp>;
 using folded_std_subi = FoldedValueBuilder<SubIOp>;
 using folded_std_sub_view = FoldedValueBuilder<SubViewOp>;
 using folded_std_tensor_load = FoldedValueBuilder<TensorLoadOp>;
-using folded_std_view = FoldedValueBuilder<ViewOp>;
 using folded_std_zero_extendi = FoldedValueBuilder<ZeroExtendIOp>;
 using folded_std_sign_extendi = FoldedValueBuilder<SignExtendIOp>;
 using folded_tensor_extract = FoldedValueBuilder<tensor::ExtractOp>;
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_EDSC_FOLDEDINTRINSICS_H_

mlir/include/mlir/Dialect/Linalg/Passes.h

 std::unique_ptr<OperationPass<FuncOp>>
 createLinalgTilingToParallelLoopsPass(ArrayRef<int64_t> tileSizes = {});
 
 std::unique_ptr<OperationPass<FuncOp>>
 createLinalgPromotionPass(bool dynamicBuffers, bool useAlloca);
 std::unique_ptr<OperationPass<FuncOp>> createLinalgPromotionPass();
 
 /// Create a pass to convert Linalg operations to scf.for loops and
-/// std.load/std.store accesses.
+/// std.load/memref.store accesses.
 std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToLoopsPass();
 
 /// Create a pass to convert Linalg operations to scf.parallel loops and
-/// std.load/std.store accesses.
+/// std.load/memref.store accesses.
 std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToParallelLoopsPass();
 
 /// Create a pass to convert Linalg operations to affine.for loops and
 /// affine_load/affine_store accesses.
 /// Placeholder for now, this is NYI.
 std::unique_ptr<OperationPass<FuncOp>> createConvertLinalgToAffineLoopsPass();
 
 /// Create a pass to convert Linalg operations which work on tensors to use

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

struct PadTensorOpVectorizationPattern : public OpRewritePattern<PadTensorOp> {
 
   LogicalResult matchAndRewrite(PadTensorOp padOp,
                                 PatternRewriter &rewriter) const override;
 };
 
 /// Match and rewrite for the pattern:
 /// ```
 ///    %alloc = ...
-///    [optional] %view = std.view %alloc ...
+///    [optional] %view = memref.view %alloc ...
 ///    %subView = subview %allocOrView ...
 ///    [optional] linalg.fill(%allocOrView, %cst) ...
 ///    ...
 ///    linalg.copy(%in, %subView) ...
 ///    vector.transfer_read %allocOrView[...], %cst ...
 /// ```
 /// into
 /// ```
 ///    [unchanged] %alloc = ...
-///    [unchanged] [optional] %view = std.view %alloc ...
+///    [unchanged] [optional] %view = memref.view %alloc ...
 ///    [unchanged] [unchanged] %subView = subview %allocOrView ...
 ///    ...
 ///    vector.transfer_read %in[...], %cst ...
 /// ```
 /// Where there is no interleaved use between linalg.copy and transfer_read as
 /// well as no interleaved use between linalg.fill and linalg.copy (if
 /// linalg.fill is specified).
 /// This is a custom rewrite to forward partial reads (with optional fills) to
 /// vector.transfer_read.
 struct LinalgCopyVTRForwardingPattern
     : public OpRewritePattern<vector::TransferReadOp> {
   using OpRewritePattern<vector::TransferReadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferReadOp xferOp,
                                 PatternRewriter &rewriter) const override;
 };
 
 /// Match and rewrite for the pattern:
 /// ```
 ///    %alloc = ...
-///    [optional] %view = std.view %alloc ...
+///    [optional] %view = memref.view %alloc ...
 ///    %subView = subview %allocOrView...
 ///    ...
 ///    vector.transfer_write %..., %allocOrView[...]
 ///    linalg.copy(%subView, %out)
 /// ```
 /// into
 /// ```
 ///    [unchanged] %alloc = ...
-///    [unchanged] [optional] %view = std.view %alloc ...
+///    [unchanged] [optional] %view = memref.view %alloc ...
 ///    [unchanged] %subView = subview %allocOrView...
 ///    ...
 ///    vector.transfer_write %..., %out[...]
 /// ```
 /// Where there is no interleaved use between transfer_write and linalg.copy.
 /// This is a custom rewrite to forward partial writes to vector.transfer_write.
 struct LinalgCopyVTWForwardingPattern
     : public OpRewritePattern<vector::TransferWriteOp> {

mlir/include/mlir/Dialect/MemRef/CMakeLists.txt

+add_subdirectory(IR)

mlir/include/mlir/Dialect/MemRef/IR/CMakeLists.txt

+add_mlir_dialect(MemRefOps memref)
+add_mlir_doc(MemRefOps -gen-dialect-doc MemRefOps Dialects/)

mlir/include/mlir/Dialect/MemRef/IR/MemRef.h

+//===- MemRef.h - MemRef 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_MEMREF_IR_MEMREF_H_
+#define MLIR_DIALECT_MEMREF_IR_MEMREF_H_
+
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/CastInterfaces.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
+
+//===----------------------------------------------------------------------===//
+// MemRef Dialect
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.h.inc"
+
+//===----------------------------------------------------------------------===//
+// MemRef Dialect Operations
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/MemRef/IR/MemRefOps.h.inc"
+
+#endif // MLIR_DIALECT_MEMREF_IR_MEMREF_H_

mlir/include/mlir/Dialect/MemRef/IR/MemRefBase.td

+//===- MemRefBase.td - Base definitions for memref dialect -*- tablegen -*-===//
+//
+// 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 MEMREF_BASE
+#define MEMREF_BASE
+
+include "mlir/IR/OpBase.td"
+
+def MemRef_Dialect : Dialect {
+  let name = "memref";
+  let cppNamespace = "::mlir::memref";
+  let description = [{
+    The `memref` dialect is intended to hold core memref creation and
+    manipulation ops, which are not strongly associated with any particular
+    other dialect or domain abstraction.
+  }];
+}
+
+#endif // MEMREF_BASE

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

+//===- MemRefOps.td - MemRef op definitions ----------------*- tablegen -*-===//
+//
+// 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 MEMREF_OPS
+#define MEMREF_OPS
+
+include "mlir/Dialect/MemRef/IR/MemRefBase.td"
+include "mlir/Interfaces/CastInterfaces.td"
+include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/Interfaces/ViewLikeInterface.td"
+include "mlir/IR/SymbolInterfaces.td"
+
+class MemRef_Op<string mnemonic, list<OpTrait> traits = []>
+    : Op<MemRef_Dialect, mnemonic, traits> {
+  let printer = [{ return ::print(p, *this); }];
+  let verifier = [{ return ::verify(*this); }];
+  let parser = [{ return ::parse$cppClass(parser, result); }];
+}
+
+//===----------------------------------------------------------------------===//
+// AllocLikeOp
+//===----------------------------------------------------------------------===//
+
+// Base class for memref allocating ops: alloca and alloc.
+//
+//   %0 = alloclike(%m)[%s] : memref<8x?xf32, (d0, d1)[s0] -> ((d0 + s0), d1)>
+//
+class AllocLikeOp<string mnemonic,
+                  Resource resource,
+                  list<OpTrait> traits = []> :
+    MemRef_Op<mnemonic,
+    !listconcat([
+      AttrSizedOperandSegments
+    ], traits)> {
+
+  let arguments = (ins Variadic<Index>:$dynamicSizes,
+                   // The symbolic operands (the ones in square brackets) bind
+                   // to the symbols of the memref's layout map.
+                   Variadic<Index>:$symbolOperands,
+                   Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
+  let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>:$memref);
+
+  let builders = [
+    OpBuilderDAG<(ins "MemRefType":$memrefType,
+                  CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
+      return build($_builder, $_state, memrefType, {}, alignment);
+    }]>,
+    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
+                  CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
+      return build($_builder, $_state, memrefType, dynamicSizes, {}, alignment);
+    }]>,
+    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
+                  "ValueRange":$symbolOperands,
+                  CArg<"IntegerAttr", "{}">:$alignment), [{
+      $_state.types.push_back(memrefType);
+      $_state.addOperands(dynamicSizes);
+      $_state.addOperands(symbolOperands);
+      $_state.addAttribute(getOperandSegmentSizeAttr(),
+          $_builder.getI32VectorAttr({
+              static_cast<int32_t>(dynamicSizes.size()),
+              static_cast<int32_t>(symbolOperands.size())}));
+      if (alignment)
+        $_state.addAttribute(getAlignmentAttrName(), alignment);
+    }]>];
+
+  let extraClassDeclaration = [{
+    static StringRef getAlignmentAttrName() { return "alignment"; }
+
+    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
+
+    /// Returns the dynamic sizes for this alloc operation if specified.
+    operand_range getDynamicSizes() { return dynamicSizes(); }
+  }];
+
+  let assemblyFormat = [{
+    `(`$dynamicSizes`)` (`` `[` $symbolOperands^ `]`)? attr-dict `:` type($memref)
+  }];
+
+  let hasCanonicalizer = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// BaseCastOp
+//===----------------------------------------------------------------------===//
+
+// Base class for standard cast operations. Requires single operand and result,
+// but does not constrain them to specific types.
+class CastOp<string mnemonic, list<OpTrait> traits = []> :
+    MemRef_Op<mnemonic, traits # [
+      NoSideEffect, SameOperandsAndResultShape,
+      DeclareOpInterfaceMethods<CastOpInterface>
+    ]> {
+  let results = (outs AnyType);
+
+  let builders = [
+    OpBuilderDAG<(ins "Value":$source, "Type":$destType), [{
+       impl::buildCastOp($_builder, $_state, source, destType);
+    }]>
+  ];
+
+  let parser = [{
+    return impl::parseCastOp(parser, result);
+  }];
+  let printer = [{
+    return printStandardCastOp(this->getOperation(), p);
+  }];
+
+  // Cast operations are fully verified by its traits.
+  let verifier = ?;
+}
+
+//===----------------------------------------------------------------------===//
+// AllocOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_AllocOp : AllocLikeOp<"alloc", DefaultResource> {
+  let summary = "memory allocation operation";
+  let description = [{
+    The `alloc` operation allocates a region of memory, as specified by its
+    memref type.
+
+    Example:
+
+    ```mlir
+    %0 = memref.alloc() : memref<8x64xf32, 1>
+    ```
+
+    The optional list of dimension operands are bound to the dynamic dimensions
+    specified in its memref type. In the example below, the ssa value '%d' is
+    bound to the second dimension of the memref (which is dynamic).
+
+    ```mlir
+    %0 = memref.alloc(%d) : memref<8x?xf32, 1>
+    ```
+
+    The optional list of symbol operands are bound to the symbols of the
+    memrefs affine map. In the example below, the ssa value '%s' is bound to
+    the symbol 's0' in the affine map specified in the allocs memref type.
+
+    ```mlir
+    %0 = memref.alloc()[%s] : memref<8x64xf32,
+                              affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+    ```
+
+    This operation returns a single ssa value of memref type, which can be used
+    by subsequent load and store operations.
+
+    The optional `alignment` attribute may be specified to ensure that the
+    region of memory that will be indexed is aligned at the specified byte
+    boundary.
+
+    ```mlir
+    %0 = memref.alloc()[%s] {alignment = 8} :
+      memref<8x64xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+    ```
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// AllocaOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
+  let summary = "stack memory allocation operation";
+  let description = [{
+    The `alloca` operation allocates memory on the stack, to be automatically
+    released when control transfers back from the region of its closest
+    surrounding operation with an
+    [`AutomaticAllocationScope`](../Traits.md#automaticallocationscope) trait.
+    The amount of memory allocated is specified by its memref and additional
+    operands. For example:
+
+    ```mlir
+    %0 = memref.alloca() : memref<8x64xf32>
+    ```
+
+    The optional list of dimension operands are bound to the dynamic dimensions
+    specified in its memref type. In the example below, the SSA value '%d' is
+    bound to the second dimension of the memref (which is dynamic).
+
+    ```mlir
+    %0 = memref.alloca(%d) : memref<8x?xf32>
+    ```
+
+    The optional list of symbol operands are bound to the symbols of the
+    memref's affine map. In the example below, the SSA value '%s' is bound to
+    the symbol 's0' in the affine map specified in the allocs memref type.
+
+    ```mlir
+    %0 = memref.alloca()[%s] : memref<8x64xf32,
+                               affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>>
+    ```
+
+    This operation returns a single SSA value of memref type, which can be used
+    by subsequent load and store operations. An optional alignment attribute, if
+    specified, guarantees alignment at least to that boundary. If not specified,
+    an alignment on any convenient boundary compatible with the type will be
+    chosen.
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// CastOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_CastOp : CastOp<"cast", [NoSideEffect]> {
+  let summary = "memref cast operation";
+  let description = [{
+    Syntax:
+
+    ```
+    operation ::= ssa-id `=` `memref.cast` ssa-use `:` type `to` type
+    ```
+
+    The `memref.cast` operation converts a memref from one type to an equivalent
+    type with a compatible shape. The source and destination types are
+    compatible if:
+
+    a. Both are ranked memref types with the same element type, address space,
+    and rank and:
+      1. Both have the same layout or both have compatible strided layouts.
+      2. The individual sizes (resp. offset and strides in the case of strided
+         memrefs) may convert constant dimensions to dynamic dimensions and
+         vice-versa.
+
+    If the cast converts any dimensions from an unknown to a known size, then it
+    acts as an assertion that fails at runtime if the dynamic dimensions
+    disagree with resultant destination size.
+
+    Example:
+
+    ```mlir
+    // Assert that the input dynamic shape matches the destination static shape.
+    %2 = memref.cast %1 : memref<?x?xf32> to memref<4x4xf32>
+    // Erase static shape information, replacing it with dynamic information.
+    %3 = memref.cast %1 : memref<4xf32> to memref<?xf32>
+
+    // The same holds true for offsets and strides.
+
+    // Assert that the input dynamic shape matches the destination static stride.
+    %4 = memref.cast %1 : memref<12x4xf32, offset:?, strides: [?, ?]> to
+                          memref<12x4xf32, offset:5, strides: [4, 1]>
+    // Erase static offset and stride information, replacing it with
+    // dynamic information.
+    %5 = memref.cast %1 : memref<12x4xf32, offset:5, strides: [4, 1]> to
+                          memref<12x4xf32, offset:?, strides: [?, ?]>
+    ```
+
+    b. Either or both memref types are unranked with the same element type, and
+    address space.
+
+    Example:
+
+    ```mlir
+    Cast to concrete shape.
+        %4 = memref.cast %1 : memref<*xf32> to memref<4x?xf32>
+
+    Erase rank information.
+        %5 = memref.cast %1 : memref<4x?xf32> to memref<*xf32>
+    ```
+  }];
+
+  let arguments = (ins AnyRankedOrUnrankedMemRef:$source);
+  let results = (outs AnyRankedOrUnrankedMemRef:$dest);
+  let assemblyFormat = "$source attr-dict `:` type($source) `to` type($dest)";
+  let verifier = "return impl::verifyCastOp(*this, areCastCompatible);";
+  let builders = [
+    OpBuilderDAG<(ins "Value":$source, "Type":$destType), [{
+       impl::buildCastOp($_builder, $_state, source, destType);
+    }]>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Fold the given CastOp into consumer op.
+    static bool canFoldIntoConsumerOp(CastOp castOp);
+  }];
+
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// DeallocOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_DeallocOp : MemRef_Op<"dealloc", [MemRefsNormalizable]> {
+  let summary = "memory deallocation operation";
+  let description = [{
+    The `dealloc` operation frees the region of memory referenced by a memref
+    which was originally created by the `alloc` operation.
+    The `dealloc` operation should not be called on memrefs which alias an
+    alloc'd memref (e.g. memrefs returned by `view` operations).
+
+    Example:
+
+    ```mlir
+    %0 = memref.alloc() : memref<8x64xf32, (d0, d1) -> (d0, d1), 1>
+    memref.dealloc %0 : memref<8x64xf32, (d0, d1) -> (d0, d1), 1>
+    ```
+  }];
+
+  let arguments = (ins Arg<AnyMemRef, "", [MemFree]>:$memref);
+
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+  let assemblyFormat = "$memref attr-dict `:` type($memref)";
+}
+
+//===----------------------------------------------------------------------===//
+// GetGlobalOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_GetGlobalOp : MemRef_Op<"get_global",
+    [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+  let summary = "get the memref pointing to a global variable";
+  let description = [{
+     The `memref.get_global` operation retrieves the memref pointing to a
+     named global variable. If the global variable is marked constant, writing
+     to the result memref (such as through a `memref.store` operation) is
+     undefined.
+
+     Example:
+
+     ```mlir
+     %x = memref.get_global @foo : memref<2xf32>
+     ```
+  }];
+
+  let arguments = (ins FlatSymbolRefAttr:$name);
+  let results = (outs AnyStaticShapeMemRef:$result);
+  let assemblyFormat = "$name `:` type($result) attr-dict";
+
+  // `GetGlobalOp` is fully verified by its traits.
+  let verifier = ?;
+}
+
+//===----------------------------------------------------------------------===//
+// GlobalOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_GlobalOp : MemRef_Op<"global", [Symbol]> {
+  let summary = "declare or define a global memref variable";
+  let description = [{
+    The `memref.global` operation declares or defines a named global variable.
+    The backing memory for the variable is allocated statically and is described
+    by the type of the variable (which should be a statically shaped memref
+    type). The operation is a declaration if no `inital_value` is specified,
+    else it is a definition. The `initial_value` can either be a unit attribute
+    to represent a definition of an uninitialized global variable, or an
+    elements attribute to represent the definition of a global variable with an
+    initial value. The global variable can also be marked constant using the
+    `constant` unit attribute. Writing to such constant global variables is
+    undefined.
+
+    The global variable can be accessed by using the `memref.get_global` to
+    retrieve the memref for the global variable. Note that the memref
+    for such global variable itself is immutable (i.e., memref.get_global for a
+    given global variable will always return the same memref descriptor).
+
+    Example:
+
+    ```mlir
+    // Private variable with an initial value.
+    memref.global "private" @x : memref<2xf32> = dense<0.0,2.0>
+
+    // Declaration of an external variable.
+    memref.global "private" @y : memref<4xi32>
+
+    // Uninitialized externally visible variable.
+    memref.global @z : memref<3xf16> = uninitialized
+
+    // Externally visible constant variable.
+    memref.global constant @c : memref<2xi32> = dense<1, 4>
+    ```
+  }];
+
+  let arguments = (ins
+      SymbolNameAttr:$sym_name,
+      OptionalAttr<StrAttr>:$sym_visibility,
+      TypeAttr:$type,
+      OptionalAttr<AnyAttr>:$initial_value,
+      UnitAttr:$constant
+  );
+
+  let assemblyFormat = [{
+       ($sym_visibility^)?
+       (`constant` $constant^)?
+       $sym_name `:`
+       custom<GlobalMemrefOpTypeAndInitialValue>($type, $initial_value)
+       attr-dict
+  }];
+
+  let extraClassDeclaration = [{
+     bool isExternal() { return !initial_value(); }
+     bool isUninitialized() {
+       return !isExternal() && initial_value().getValue().isa<UnitAttr>();
+     }
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// PrefetchOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_PrefetchOp : MemRef_Op<"prefetch"> {
+  let summary = "prefetch operation";
+  let description = [{
+    The "prefetch" op prefetches data from a memref location described with
+    subscript indices similar to std.load, and with three attributes: a
+    read/write specifier, a locality hint, and a cache type specifier as shown
+    below:
+
+    ```mlir
+    memref.prefetch %0[%i, %j], read, locality<3>, data : memref<400x400xi32>
+    ```
+
+    The read/write specifier is either 'read' or 'write', the locality hint
+    ranges from locality<0> (no locality) to locality<3> (extremely local keep
+    in cache). The cache type specifier is either 'data' or 'instr'
+    and specifies whether the prefetch is performed on data cache or on
+    instruction cache.
+  }];
+
+  let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
+                   BoolAttr:$isWrite,
+                   Confined<I32Attr, [IntMinValue<0>,
+                     IntMaxValue<3>]>:$localityHint,
+                   BoolAttr:$isDataCache);
+
+  let extraClassDeclaration = [{
+    MemRefType getMemRefType() {
+      return memref().getType().cast<MemRefType>();
+    }
+    static StringRef getLocalityHintAttrName() { return "localityHint"; }
+    static StringRef getIsWriteAttrName() { return "isWrite"; }
+    static StringRef getIsDataCacheAttrName() { return "isDataCache"; }
+  }];
+
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// ReshapeOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_ReshapeOp: MemRef_Op<"reshape", [
+    ViewLikeOpInterface, NoSideEffect]>  {
+  let summary = "memref reshape operation";
+  let description = [{
+    The `reshape` operation converts a memref from one type to an
+    equivalent type with a provided shape. The data is never copied or
+    modified. The source and destination types are compatible if both have the
+    same element type, same number of elements, address space and identity
+    layout map. The following combinations are possible:
+
+    a. Source type is ranked or unranked. Shape argument has static size.
+    Result type is ranked.
+
+    ```mlir
+    // Reshape statically-shaped memref.
+    %dst = memref.reshape %src(%shape)
+             : (memref<4x1xf32>, memref<1xi32>) to memref<4xf32>
+    %dst0 = memref.reshape %src(%shape0)
+             : (memref<4x1xf32>, memref<2xi32>) to memref<2x2xf32>
+    // Flatten unranked memref.
+    %dst = memref.reshape %src(%shape)
+             : (memref<*xf32>, memref<1xi32>) to memref<?xf32>
+    ```
+
+    b. Source type is ranked or unranked. Shape argument has dynamic size.
+    Result type is unranked.
+
+    ```mlir
+    // Reshape dynamically-shaped 1D memref.
+    %dst = memref.reshape %src(%shape)
+             : (memref<?xf32>, memref<?xi32>) to memref<*xf32>
+    // Reshape unranked memref.
+    %dst = memref.reshape %src(%shape)
+             : (memref<*xf32>, memref<?xi32>) to memref<*xf32>
+    ```
+  }];
+
+  let arguments = (ins
+    AnyRankedOrUnrankedMemRef:$source,
+    MemRefRankOf<[AnySignlessInteger, Index], [1]>:$shape
+  );
+  let results = (outs AnyRankedOrUnrankedMemRef:$result);
+
+  let builders = [OpBuilderDAG<
+     (ins "MemRefType":$resultType, "Value":$operand, "Value":$shape), [{
+       $_state.addOperands(operand);
+       $_state.addOperands(shape);
+       $_state.addTypes(resultType);
+     }]>];
+
+  let extraClassDeclaration = [{
+    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
+    Value getViewSource() { return source(); }
+  }];
+
+  let assemblyFormat = [{
+    $source `(` $shape `)` attr-dict `:` functional-type(operands, results)
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// StoreOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_StoreOp : MemRef_Op<"store",
+     [TypesMatchWith<"type of 'value' matches element type of 'memref'",
+                     "memref", "value",
+                     "$_self.cast<MemRefType>().getElementType()">,
+                     MemRefsNormalizable]> {
+  let summary = "store operation";
+  let description = [{
+    Store a value to a memref location given by indices. The value stored should
+    have the same type as the elemental type of the memref. The number of
+    arguments provided within brackets need to match the rank of the memref.
+
+    In an affine context, the indices of a store are restricted to SSA values
+    bound to surrounding loop induction variables,
+    [symbols](Affine.md#restrictions-on-dimensions-and-symbols), results of a
+    [`constant` operation](#stdconstant-constantop), or the result of an
+    [`affine.apply`](Affine.md#affineapply-affineapplyop) operation that can in
+    turn take as arguments all of the aforementioned SSA values or the
+    recursively result of such an `affine.apply` operation.
+
+    Example:
+
+    ```mlir
+    memref.store %100, %A[%1, 1023] : memref<4x?xf32, #layout, memspace0>
+    ```
+
+    **Context:** The `load` and `store` operations are specifically crafted to
+    fully resolve a reference to an element of a memref, and (in polyhedral
+    `affine.if` and `affine.for` operations) the compiler can follow use-def
+    chains (e.g. through [`affine.apply`](Affine.md#affineapply-affineapplyop)
+    operations) to precisely analyze references at compile-time using polyhedral
+    techniques. This is possible because of the
+    [restrictions on dimensions and symbols](Affine.md#restrictions-on-dimensions-and-symbols)
+    in these contexts.
+  }];
+
+  let arguments = (ins AnyType:$value,
+                       Arg<AnyMemRef, "the reference to store to",
+                           [MemWrite]>:$memref,
+                       Variadic<Index>:$indices);
+
+  let builders = [
+    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref), [{
+      $_state.addOperands(valueToStore);
+      $_state.addOperands(memref);
+    }]>];
+
+  let extraClassDeclaration = [{
+      Value getValueToStore() { return getOperand(0); }
+
+      Value getMemRef() { return getOperand(1); }
+      void setMemRef(Value value) { setOperand(1, value); }
+      MemRefType getMemRefType() {
+        return getMemRef().getType().cast<MemRefType>();
+      }
+
+      operand_range getIndices() {
+        return {operand_begin() + 2, operand_end()};
+      }
+  }];
+
+  let hasFolder = 1;
+
+  let assemblyFormat = [{
+    $value `,` $memref `[` $indices `]` attr-dict `:` type($memref)
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// TransposeOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_TransposeOp : MemRef_Op<"transpose", [NoSideEffect]>,
+    Arguments<(ins AnyStridedMemRef:$in, AffineMapAttr:$permutation)>,
+    Results<(outs AnyStridedMemRef)> {
+  let summary = "`transpose` produces a new strided memref (metadata-only)";
+  let description = [{
+    The `transpose` op produces a strided memref whose sizes and strides
+    are a permutation of the original `in` memref. This is purely a metadata
+    transformation.
+
+    Example:
+
+    ```mlir
+    %1 = memref.transpose %0 (i, j) -> (j, i) : memref<?x?xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>>
+    ```
+  }];
+
+  let builders = [
+    OpBuilderDAG<(ins "Value":$in, "AffineMapAttr":$permutation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
+
+  let extraClassDeclaration = [{
+    static StringRef getPermutationAttrName() { return "permutation"; }
+    ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
+  }];
+
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
+// ViewOp
+//===----------------------------------------------------------------------===//
+
+def MemRef_ViewOp : MemRef_Op<"view", [
+    DeclareOpInterfaceMethods<ViewLikeOpInterface>, NoSideEffect]> {
+  let summary = "memref view operation";
+  let description = [{
+    The "view" operation extracts an N-D contiguous memref with empty layout map
+    with arbitrary element type from a 1-D contiguous memref with empty layout
+    map of i8 element  type. The ViewOp supports the following arguments:
+
+    * A single dynamic byte-shift operand must be specified which represents a
+      a shift of the base 1-D memref pointer from which to create the resulting
+      contiguous memref view with identity layout.
+    * A dynamic size operand that must be specified for each dynamic dimension
+      in the resulting view memref type.
+
+    The "view" operation gives a structured indexing form to a flat 1-D buffer.
+    Unlike "subview" it can perform a type change. The type change behavior
+    requires the op to have special semantics because, e.g. a byte shift of 3
+    cannot be represented as an offset on f64.
+    For now, a "view" op:
+
+    1. Only takes a contiguous source memref with 0 offset and empty layout.
+    2. Must specify a byte_shift operand (in the future, a special integer
+       attribute may be added to support the folded case).
+    3. Returns a contiguous memref with 0 offset and empty layout.
+
+    Example:
+
+    ```mlir
+    // Allocate a flat 1D/i8 memref.
+    %0 = memref.alloc() : memref<2048xi8>
+
+    // ViewOp with dynamic offset and static sizes.
+    %1 = memref.view %0[%offset_1024][] : memref<2048xi8> to memref<64x4xf32>
+
+    // ViewOp with dynamic offset and two dynamic size.
+    %2 = memref.view %0[%offset_1024][%size0, %size1] :
+      memref<2048xi8> to memref<?x4x?xf32>
+    ```
+  }];
+
+  let arguments = (ins MemRefRankOf<[I8], [1]>:$source,
+                   Index:$byte_shift,
+                   Variadic<Index>:$sizes);
+  let results = (outs AnyMemRef);
+
+  let extraClassDeclaration = [{
+    /// The result of a view is always a memref.
+    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
+
+    /// Returns the dynamic sizes for this view operation. This is redundant
+    /// with `sizes` but needed in template implementations. More specifically:
+    /// ```
+    /// template <typename AnyMemRefDefOp>
+    /// bool isMemRefSizeValidSymbol(AnyMemRefDefOp memrefDefOp, unsigned index,
+    ///                              Region *region)
+    /// ```
+    operand_range getDynamicSizes() {
+      return {sizes().begin(), sizes().end()};
+    }
+  }];
+
+  let hasCanonicalizer = 1;
+}
+
+#endif // MEMREF_OPS

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/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/EDSC/Builders.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.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_store = OperationBuilder<memref::StoreOp>;
+using memref_view = ValueBuilder<memref::ViewOp>;
 using std_addi = ValueBuilder<AddIOp>;
 using std_addf = ValueBuilder<AddFOp>;
-using std_alloc = ValueBuilder<AllocOp>;
-using std_alloca = ValueBuilder<AllocaOp>;
 using std_call = OperationBuilder<CallOp>;
 using std_constant = ValueBuilder<ConstantOp>;
 using std_constant_float = ValueBuilder<ConstantFloatOp>;
 using std_constant_index = ValueBuilder<ConstantIndexOp>;
 using std_constant_int = ValueBuilder<ConstantIntOp>;
-using std_dealloc = OperationBuilder<DeallocOp>;
 using std_divis = ValueBuilder<SignedDivIOp>;
 using std_diviu = ValueBuilder<UnsignedDivIOp>;
 using std_dim = ValueBuilder<DimOp>;
 using std_fpext = ValueBuilder<FPExtOp>;
 using std_fptrunc = ValueBuilder<FPTruncOp>;
 using std_index_cast = ValueBuilder<IndexCastOp>;
 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_sign_extendi = ValueBuilder<SignExtendIOp>;
 using std_splat = ValueBuilder<SplatOp>;
-using std_store = OperationBuilder<StoreOp>;
 using std_subf = ValueBuilder<SubFOp>;
 using std_subi = ValueBuilder<SubIOp>;
 using std_sub_view = ValueBuilder<SubViewOp>;
 using std_tensor_load = ValueBuilder<TensorLoadOp>;
 using std_tensor_store = OperationBuilder<TensorStoreOp>;
-using std_view = ValueBuilder<ViewOp>;
 using std_zero_extendi = ValueBuilder<ZeroExtendIOp>;
 using tensor_extract = ValueBuilder<tensor::ExtractOp>;
 
 template <int N>
 struct SExtiValueBuilder : public ValueBuilder<SignExtendIOp> {
   using ValueBuilder<SignExtendIOp>::ValueBuilder;
   template <typename... Args>
   SExtiValueBuilder(Args... args)
       : ValueBuilder<SignExtendIOp>(ScopedContext::getBuilderRef().getI32Type(),
                                     args...) {}
 };
 
 using std_sexti32 = SExtiValueBuilder<32>;
 
 /// Branches into `block` with `operands`.
 BranchOp std_br(Block *block, ValueRange operands);
 
 /// Branches into `trueBranch` with `trueOperands` if `cond` evaluates to `true`
 /// or to `falseBranch` and `falseOperand` if `cond` evaluates to `false`.
 CondBranchOp std_cond_br(Value cond, Block *trueBranch, ValueRange trueOperands,
                          Block *falseBranch, ValueRange falseOperands);
 
 /// Provide an index notation around sdt_load and std_store.
 using StdIndexedValue =
-    TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
+    TemplatedIndexedValue<intrinsics::std_load, intrinsics::memref_store>;
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 /// `originalShape` to obtain the `reducedShape`. This mask is useful to track
 /// which dimensions must be kept when e.g. compute MemRef strides under
 /// rank-reducing operations. Return None if reducedShape cannot be obtained
 /// by dropping only `1` entries in `originalShape`.
 llvm::Optional<llvm::SmallDenseSet<unsigned>>
 computeRankReductionMask(ArrayRef<int64_t> originalShape,
                          ArrayRef<int64_t> reducedShape);
 
-/// Determines whether MemRefCastOp casts to a more dynamic version of the
-/// source memref. This is useful to to fold a memref_cast into a consuming op
-/// and implement canonicalization patterns for ops in different dialects that
-/// may consume the results of memref_cast operations. Such foldable memref_cast
-/// operations are typically inserted as `view` and `subview` ops and are
-/// canonicalized, to preserve the type compatibility of their uses.
-///
-/// Returns true when all conditions are met:
-/// 1. source and result are ranked memrefs with strided semantics and same
-/// element type and rank.
-/// 2. each of the source's size, offset or stride has more static information
-/// than the corresponding result's size, offset or stride.
-///
-/// Example 1:
-/// ```mlir
-///   %1 = memref_cast %0 : memref<8x16xf32> to memref<?x?xf32>
-///   %2 = consumer %1 ... : memref<?x?xf32> ...
-/// ```
-///
-/// may fold into:
-///
-/// ```mlir
-///   %2 = consumer %0 ... : memref<8x16xf32> ...
-/// ```
-///
-/// Example 2:
-/// ```
-///   %1 = memref_cast %0 : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
-///          to memref<?x?xf32>
-///   consumer %1 : memref<?x?xf32> ...
-/// ```
-///
-/// may fold into:
-///
-/// ```
-///   consumer %0 ... : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
-/// ```
-bool canFoldIntoConsumerOp(MemRefCastOp castOp);
-
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 /// comparison predicates.
 bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,
                        const APInt &rhs);
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
 bool applyCmpPredicate(CmpFPredicate predicate, const APFloat &lhs,
                        const APFloat &rhs);
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_IR_STANDARDOPS_IR_OPS_H

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

class Std_Op<string mnemonic, list<OpTrait> traits = []> :
   //   * ParseResult parse${C++ class of Op}(OpAsmParser &parser,
   //                                         OperationState &result)
   // functions.
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
-// Base class for standard cast operations. Requires single operand and result,
-// but does not constrain them to specific types.
-class CastOp<string mnemonic, list<OpTrait> traits = []> :
+// Base class for arithmetic cast operations. Requires single operand and
+// result, but does not constrain them to specific types.
+class ArithmeticCastOp<string mnemonic, list<OpTrait> traits = []> :
     Std_Op<mnemonic, traits # [
+      ElementwiseMappable,
+      DeclareOpInterfaceMethods<VectorUnrollOpInterface>,
       NoSideEffect, SameOperandsAndResultShape,
       DeclareOpInterfaceMethods<CastOpInterface>
     ]> {
   let results = (outs AnyType);
 
   let builders = [
     OpBuilderDAG<(ins "Value":$source, "Type":$destType), [{
        impl::buildCastOp($_builder, $_state, source, destType);
     }]>
   ];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
 
   // Cast operations are fully verified by its traits.
   let verifier = ?;
 }
 
-// Base class for arithmetic cast operations.
-class ArithmeticCastOp<string mnemonic, list<OpTrait> traits = []> :
-    CastOp<mnemonic,
-    !listconcat(traits, [ElementwiseMappable,
-                         DeclareOpInterfaceMethods<VectorUnrollOpInterface>])> {
-}
-
 // Base class for unary ops. Requires single operand and result. Individual
 // classes will have `operand` accessor.
 class UnaryOp<string mnemonic, list<OpTrait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, !listconcat(traits, [NoSideEffect])> {
   let results = (outs AnyType);
   let printer = [{
     return printStandardUnaryOp(this->getOperation(), p);
   }];

 //     <op> %0, %1, %2 : f32
 //
 class FloatTernaryOp<string mnemonic, list<OpTrait> traits = []> :
     ArithmeticTernaryOp<mnemonic,
       !listconcat(traits,
                   [DeclareOpInterfaceMethods<VectorUnrollOpInterface>])>,
     Arguments<(ins FloatLike:$a, FloatLike:$b, FloatLike:$c)>;
 
-// Base class for memref allocating ops: alloca and alloc.
-//
-//   %0 = alloclike(%m)[%s] : memref<8x?xf32, (d0, d1)[s0] -> ((d0 + s0), d1)>
-//
-class AllocLikeOp<string mnemonic,
-                  Resource resource,
-                  list<OpTrait> traits = []> :
-    Std_Op<mnemonic,
-    !listconcat([
-      AttrSizedOperandSegments
-    ], traits)> {
-
-  let arguments = (ins Variadic<Index>:$dynamicSizes,
-                   // The symbolic operands (the ones in square brackets) bind
-                   // to the symbols of the memref's layout map.
-                   Variadic<Index>:$symbolOperands,
-                   Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
-  let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>:$memref);
-
-  let builders = [
-    OpBuilderDAG<(ins "MemRefType":$memrefType,
-                  CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
-      return build($_builder, $_state, memrefType, {}, alignment);
-    }]>,
-    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
-                  CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
-      return build($_builder, $_state, memrefType, dynamicSizes, {}, alignment);
-    }]>,
-    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
-                  "ValueRange":$symbolOperands,
-                  CArg<"IntegerAttr", "{}">:$alignment), [{
-      $_state.types.push_back(memrefType);
-      $_state.addOperands(dynamicSizes);
-      $_state.addOperands(symbolOperands);
-      $_state.addAttribute(getOperandSegmentSizeAttr(),
-          $_builder.getI32VectorAttr({
-              static_cast<int32_t>(dynamicSizes.size()),
-              static_cast<int32_t>(symbolOperands.size())}));
-      if (alignment)
-        $_state.addAttribute(getAlignmentAttrName(), alignment);
-    }]>];
-
-  let extraClassDeclaration = [{
-    static StringRef getAlignmentAttrName() { return "alignment"; }
-
-    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
-
-    /// Returns the dynamic sizes for this alloc operation if specified.
-    operand_range getDynamicSizes() { return dynamicSizes(); }
-  }];
-
-  let assemblyFormat = [{
-    `(`$dynamicSizes`)` (`` `[` $symbolOperands^ `]`)? attr-dict `:` type($memref)
-  }];
-
-  let hasCanonicalizer = 1;
-}
-
 // Base class for ops with static/dynamic offset, sizes and strides
 // attributes/arguments.
 class BaseOpWithOffsetSizesAndStrides<string mnemonic, list<OpTrait> traits = []> :
     Std_Op<mnemonic,
            !listconcat(traits, [NoSideEffect, AttrSizedOperandSegments])> {
   code extraBaseClassDeclaration = [{
     /// Returns the dynamic sizes for this subview operation if specified.
     operand_range getDynamicSizes() { return sizes(); }
let description = [{
     // Tensor element-wise addition.
     %x = addi %y, %z : tensor<4x?xi8>
     ```
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// AllocOp
-//===----------------------------------------------------------------------===//
-
-def AllocOp : AllocLikeOp<"alloc", DefaultResource> {
-  let summary = "memory allocation operation";
-  let description = [{
-    The `alloc` operation allocates a region of memory, as specified by its
-    memref type.
-
-    Example:
-
-    ```mlir
-    %0 = alloc() : memref<8x64xf32, 1>
-    ```
-
-    The optional list of dimension operands are bound to the dynamic dimensions
-    specified in its memref type. In the example below, the ssa value '%d' is
-    bound to the second dimension of the memref (which is dynamic).
-
-    ```mlir
-    %0 = alloc(%d) : memref<8x?xf32, 1>
-    ```
-
-    The optional list of symbol operands are bound to the symbols of the
-    memrefs affine map. In the example below, the ssa value '%s' is bound to
-    the symbol 's0' in the affine map specified in the allocs memref type.
-
-    ```mlir
-    %0 = alloc()[%s] : memref<8x64xf32,
-                              affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
-    ```
-
-    This operation returns a single ssa value of memref type, which can be used
-    by subsequent load and store operations.
-
-    The optional `alignment` attribute may be specified to ensure that the
-    region of memory that will be indexed is aligned at the specified byte
-    boundary.
-
-    ```mlir
-    %0 = alloc()[%s] {alignment = 8} :
-      memref<8x64xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
-    ```
-  }];
-}
-
-//===----------------------------------------------------------------------===//
-// AllocaOp
-//===----------------------------------------------------------------------===//
-
-def AllocaOp : AllocLikeOp<"alloca", AutomaticAllocationScopeResource> {
-  let summary = "stack memory allocation operation";
-  let description = [{
-    The `alloca` operation allocates memory on the stack, to be automatically
-    released when control transfers back from the region of its closest
-    surrounding operation with an
-    [`AutomaticAllocationScope`](../Traits.md#automaticallocationscope) trait.
-    The amount of memory allocated is specified by its memref and additional
-    operands. For example:
-
-    ```mlir
-    %0 = alloca() : memref<8x64xf32>
-    ```
-
-    The optional list of dimension operands are bound to the dynamic dimensions
-    specified in its memref type. In the example below, the SSA value '%d' is
-    bound to the second dimension of the memref (which is dynamic).
-
-    ```mlir
-    %0 = alloca(%d) : memref<8x?xf32>
-    ```
-
-    The optional list of symbol operands are bound to the symbols of the
-    memref's affine map. In the example below, the SSA value '%s' is bound to
-    the symbol 's0' in the affine map specified in the allocs memref type.
-
-    ```mlir
-    %0 = alloca()[%s] : memref<8x64xf32,
-                               affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>>
-    ```
-
-    This operation returns a single SSA value of memref type, which can be used
-    by subsequent load and store operations. An optional alignment attribute, if
-    specified, guarantees alignment at least to that boundary. If not specified,
-    an alignment on any convenient boundary compatible with the type will be
-    chosen.
-  }];
-}
-
-//===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
 def AndOp : IntBinaryOp<"and", [Commutative]> {
   let summary = "integer binary and";
   let description = [{
     Syntax:
 
let description = [{
 
     // Tensor element-wise copysign value.
     %x = copysign %y, %z : tensor<4x?xf8>
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
-// DeallocOp
-//===----------------------------------------------------------------------===//
-
-def DeallocOp : Std_Op<"dealloc", [MemRefsNormalizable]> {
-  let summary = "memory deallocation operation";
-  let description = [{
-    The `dealloc` operation frees the region of memory referenced by a memref
-    which was originally created by the `alloc` operation.
-    The `dealloc` operation should not be called on memrefs which alias an
-    alloc'd memref (e.g. memrefs returned by `view` operations).
-
-    Example:
-
-    ```mlir
-    %0 = alloc() : memref<8x64xf32, (d0, d1) -> (d0, d1), 1>
-    dealloc %0 : memref<8x64xf32, (d0, d1) -> (d0, d1), 1>
-    ```
-  }];
-
-  let arguments = (ins Arg<AnyMemRef, "", [MemFree]>:$memref);
-
-  let hasCanonicalizer = 1;
-  let hasFolder = 1;
-  let assemblyFormat = "$memref attr-dict `:` type($memref)";
-}
-
-//===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 def DimOp : Std_Op<"dim", [NoSideEffect]> {
   let summary = "dimension index operation";
   let description = [{
     The `dim` operation takes a memref/tensor and a dimension operand of type
     `index`.
let description = [{
     Truncate a floating-point value to a smaller floating-point-typed value.
     The destination type must be strictly narrower than the source type.
     If the value cannot be exactly represented, it is rounded using the default
     rounding mode. Only scalars are currently supported.
   }];
 }
 
 //===----------------------------------------------------------------------===//
-// GlobalMemrefOp
-//===----------------------------------------------------------------------===//
-
-def GlobalMemrefOp : Std_Op<"global_memref", [Symbol]> {
-  let summary = "declare or define a global memref variable";
-  let description = [{
-    The `global_memref` operation declares or defines a named global variable.
-    The backing memory for the variable is allocated statically and is described
-    by the type of the variable (which should be a statically shaped memref
-    type). The operation is a declaration if no `inital_value` is specified,
-    else it is a definition. The `initial_value` can either be a unit attribute
-    to represent a definition of an uninitialized global variable, or an
-    elements attribute to represent the definition of a global variable with an
-    initial value. The global variable can also be marked constant using the
-    `constant` unit attribute. Writing to such constant global variables is
-    undefined.
-
-    The global variable can be accessed by using the `get_global_memref` to
-    retrieve the memref for the global variable. Note that the memref
-    for such global variable itself is immutable (i.e., get_global_memref for a
-    given global variable will always return the same memref descriptor).
-
-    Example:
-
-    ```mlir
-    // Private variable with an initial value.
-    global_memref "private" @x : memref<2xf32> = dense<0.0,2.0>
-
-    // Declaration of an external variable.
-    global_memref "private" @y : memref<4xi32>
-
-    // Uninitialized externally visible variable.
-    global_memref @z : memref<3xf16> = uninitialized
-
-    // Externally visible constant variable.
-    global_memref constant @c : memref<2xi32> = dense<1, 4>
-    ```
-  }];
-
-  let arguments = (ins
-      SymbolNameAttr:$sym_name,
-      OptionalAttr<StrAttr>:$sym_visibility,
-      TypeAttr:$type,
-      OptionalAttr<AnyAttr>:$initial_value,
-      UnitAttr:$constant
-  );
-
-  let assemblyFormat = [{
-       ($sym_visibility^)?
-       (`constant` $constant^)?
-       $sym_name `:`
-       custom<GlobalMemrefOpTypeAndInitialValue>($type, $initial_value)
-       attr-dict
-  }];
-
-  let extraClassDeclaration = [{
-     bool isExternal() { return !initial_value(); }
-     bool isUninitialized() {
-       return !isExternal() && initial_value().getValue().isa<UnitAttr>();
-     }
-  }];
-}
-
-//===----------------------------------------------------------------------===//
-// GetGlobalMemrefOp
-//===----------------------------------------------------------------------===//
-
-def GetGlobalMemrefOp : Std_Op<"get_global_memref",
-    [NoSideEffect, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
-  let summary = "get the memref pointing to a global variable";
-  let description = [{
-     The `get_global_memref` operation retrieves the memref pointing to a
-     named global variable. If the global variable is marked constant, writing
-     to the result memref (such as through a `std.store` operation) is
-     undefined.
-
-     Example:
-
-     ```mlir
-     %x = get_global_memref @foo : memref<2xf32>
-     ```
-  }];
-
-  let arguments = (ins FlatSymbolRefAttr:$name);
-  let results = (outs AnyStaticShapeMemRef:$result);
-  let assemblyFormat = "$name `:` type($result) attr-dict";
-
-  // `GetGlobalMemrefOp` is fully verified by its traits.
-  let verifier = ?;
-}
-
-//===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
 def IndexCastOp : ArithmeticCastOp<"index_cast">, Arguments<(ins AnyType:$in)> {
   let summary = "cast between index and integer types";
   let description = [{
     Casts between integer scalars and 'index' scalars. Index is an integer of
     platform-specific bit width. If casting to a wider integer, the value is
def LoadOp : Std_Op<"load",
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 
   let assemblyFormat = "$memref `[` $indices `]` attr-dict `:` type($memref)";
 }
 
 //===----------------------------------------------------------------------===//
-// MemRefCastOp
-//===----------------------------------------------------------------------===//
-
-def MemRefCastOp : CastOp<"memref_cast", [
-    DeclareOpInterfaceMethods<ViewLikeOpInterface>
-  ]> {
-  let summary = "memref cast operation";
-  let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `std.memref_cast` ssa-use `:` type `to` type
-    ```
-
-    The `memref_cast` operation converts a memref from one type to an equivalent
-    type with a compatible shape. The source and destination types are
-    compatible if:
-
-    a. Both are ranked memref types with the same element type, address space,
-    and rank and:
-      1. Both have the same layout or both have compatible strided layouts.
-      2. The individual sizes (resp. offset and strides in the case of strided
-         memrefs) may convert constant dimensions to dynamic dimensions and
-         vice-versa.
-
-    If the cast converts any dimensions from an unknown to a known size, then it
-    acts as an assertion that fails at runtime if the dynamic dimensions
-    disagree with resultant destination size.
-
-    Example:
-
-    ```mlir
-    // Assert that the input dynamic shape matches the destination static shape.
-    %2 = memref_cast %1 : memref<?x?xf32> to memref<4x4xf32>
-    // Erase static shape information, replacing it with dynamic information.
-    %3 = memref_cast %1 : memref<4xf32> to memref<?xf32>
-
-    // The same holds true for offsets and strides.
-
-    // Assert that the input dynamic shape matches the destination static stride.
-    %4 = memref_cast %1 : memref<12x4xf32, offset:?, strides: [?, ?]> to
-                          memref<12x4xf32, offset:5, strides: [4, 1]>
-    // Erase static offset and stride information, replacing it with
-    // dynamic information.
-    %5 = memref_cast %1 : memref<12x4xf32, offset:5, strides: [4, 1]> to
-                          memref<12x4xf32, offset:?, strides: [?, ?]>
-    ```
-
-    b. Either or both memref types are unranked with the same element type, and
-    address space.
-
-    Example:
-
-    ```mlir
-    Cast to concrete shape.
-        %4 = memref_cast %1 : memref<*xf32> to memref<4x?xf32>
-
-    Erase rank information.
-        %5 = memref_cast %1 : memref<4x?xf32> to memref<*xf32>
-    ```
-  }];
-
-  let arguments = (ins AnyRankedOrUnrankedMemRef:$source);
-  let results = (outs AnyRankedOrUnrankedMemRef);
-
-  let hasFolder = 1;
-}
-
-
-//===----------------------------------------------------------------------===//
 // MemRefReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 def MemRefReinterpretCastOp:
     BaseOpWithOffsetSizesAndStrides<"memref_reinterpret_cast", [
       NoSideEffect, ViewLikeOpInterface, OffsetSizeAndStrideOpInterface
     ]> {
   let summary = "memref reinterpret cast operation";
let description = [{
     // Tensor element-wise bitwise integer or.
     %x = or %y, %z : tensor<4x?xi8>
     ```
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// PrefetchOp
-//===----------------------------------------------------------------------===//
-
-def PrefetchOp : Std_Op<"prefetch"> {
-  let summary = "prefetch operation";
-  let description = [{
-    The "prefetch" op prefetches data from a memref location described with
-    subscript indices similar to std.load, and with three attributes: a
-    read/write specifier, a locality hint, and a cache type specifier as shown
-    below:
-
-    ```mlir
-    prefetch %0[%i, %j], read, locality<3>, data : memref<400x400xi32>
-    ```
-
-    The read/write specifier is either 'read' or 'write', the locality hint
-    ranges from locality<0> (no locality) to locality<3> (extremely local keep
-    in cache). The cache type specifier is either 'data' or 'instr'
-    and specifies whether the prefetch is performed on data cache or on
-    instruction cache.
-  }];
-
-  let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
-                   BoolAttr:$isWrite,
-                   Confined<I32Attr, [IntMinValue<0>,
-                     IntMaxValue<3>]>:$localityHint,
-                   BoolAttr:$isDataCache);
-
-  let extraClassDeclaration = [{
-    MemRefType getMemRefType() {
-      return memref().getType().cast<MemRefType>();
-    }
-    static StringRef getLocalityHintAttrName() { return "localityHint"; }
-    static StringRef getIsWriteAttrName() { return "isWrite"; }
-    static StringRef getIsDataCacheAttrName() { return "isDataCache"; }
-  }];
-
-  let hasFolder = 1;
-}
-
-//===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 def RankOp : Std_Op<"rank", [NoSideEffect]> {
   let summary = "rank operation";
   let description = [{
     The `rank` operation takes a memref/tensor operand and returns its rank.
 
let builders = [
     [{ build($_builder, $_state, aggregateType, element); }]>];
 
   let hasFolder = 1;
 
   let assemblyFormat = "$input attr-dict `:` type($aggregate)";
 }
 
 //===----------------------------------------------------------------------===//
-// StoreOp
-//===----------------------------------------------------------------------===//
-
-def StoreOp : Std_Op<"store",
-     [TypesMatchWith<"type of 'value' matches element type of 'memref'",
-                     "memref", "value",
-                     "$_self.cast<MemRefType>().getElementType()">,
-                     MemRefsNormalizable]> {
-  let summary = "store operation";
-  let description = [{
-    Store a value to a memref location given by indices. The value stored should
-    have the same type as the elemental type of the memref. The number of
-    arguments provided within brackets need to match the rank of the memref.
-
-    In an affine context, the indices of a store are restricted to SSA values
-    bound to surrounding loop induction variables,
-    [symbols](Affine.md#restrictions-on-dimensions-and-symbols), results of a
-    [`constant` operation](#stdconstant-constantop), or the result of an
-    [`affine.apply`](Affine.md#affineapply-affineapplyop) operation that can in turn
-    take as arguments all of the aforementioned SSA values or the recursively
-    result of such an `affine.apply` operation.
-
-    Example:
-
-    ```mlir
-    store %100, %A[%1, 1023] : memref<4x?xf32, #layout, memspace0>
-    ```
-
-    **Context:** The `load` and `store` operations are specifically crafted to
-    fully resolve a reference to an element of a memref, and (in polyhedral
-    `affine.if` and `affine.for` operations) the compiler can follow use-def
-    chains (e.g. through [`affine.apply`](Affine.md#affineapply-affineapplyop)
-    operations) to precisely analyze references at compile-time using polyhedral
-    techniques. This is possible because of the
-    [restrictions on dimensions and symbols](Affine.md#restrictions-on-dimensions-and-symbols)
-    in these contexts.
-  }];
-
-  let arguments = (ins AnyType:$value,
-                       Arg<AnyMemRef, "the reference to store to",
-                           [MemWrite]>:$memref,
-                       Variadic<Index>:$indices);
-
-  let builders = [
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref), [{
-      $_state.addOperands(valueToStore);
-      $_state.addOperands(memref);
-    }]>];
-
-  let extraClassDeclaration = [{
-      Value getValueToStore() { return getOperand(0); }
-
-      Value getMemRef() { return getOperand(1); }
-      void setMemRef(Value value) { setOperand(1, value); }
-      MemRefType getMemRefType() {
-        return getMemRef().getType().cast<MemRefType>();
-      }
-
-      operand_range getIndices() {
-        return {operand_begin() + 2, operand_end()};
-      }
-  }];
-
-  let hasFolder = 1;
-
-  let assemblyFormat = [{
-    $value `,` $memref `[` $indices `]` attr-dict `:` type($memref)
-  }];
-}
-
-//===----------------------------------------------------------------------===//
 // SubFOp
 //===----------------------------------------------------------------------===//
 
 def SubFOp : FloatBinaryOp<"subf"> {
   let summary = "floating point subtraction operation";
   let hasFolder = 1;
 }
 
def TensorToMemrefOp : Std_Op<"tensor_to_memref",
 
   let assemblyFormat = "$tensor attr-dict `:` type($memref)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// TransposeOp
-//===----------------------------------------------------------------------===//
-
-def TransposeOp : Std_Op<"transpose", [NoSideEffect]>,
-    Arguments<(ins AnyStridedMemRef:$in, AffineMapAttr:$permutation)>,
-    Results<(outs AnyStridedMemRef)> {
-  let summary = "`transpose` produces a new strided memref (metadata-only)";
-  let description = [{
-    The `transpose` op produces a strided memref whose sizes and strides
-    are a permutation of the original `in` memref. This is purely a metadata
-    transformation.
-
-    Example:
-
-    ```mlir
-    %1 = transpose %0 (i, j) -> (j, i) : memref<?x?xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>>
-    ```
-  }];
-
-  let builders = [
-    OpBuilderDAG<(ins "Value":$in, "AffineMapAttr":$permutation,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
-
-  let extraClassDeclaration = [{
-    static StringRef getPermutationAttrName() { return "permutation"; }
-    ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
-  }];
-
-  let hasFolder = 1;
-}
-
-//===----------------------------------------------------------------------===//
 // TruncateIOp
 //===----------------------------------------------------------------------===//
 
 def TruncateIOp : Std_Op<"trunci",
   [NoSideEffect, ElementwiseMappable,
    DeclareOpInterfaceMethods<VectorUnrollOpInterface>,]> {
   let summary = "integer truncation operation";
   let description = [{
let description = [{
     %1 = constant 160 : i8                               // %1 is 0b10100000
     %2 = constant 3 : i8
     %3 = shift_right_unsigned %1, %2 : (i8, i8) -> i8    // %3 is 0b00010100
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
-// ViewOp
-//===----------------------------------------------------------------------===//
-
-def ViewOp : Std_Op<"view", [
-    DeclareOpInterfaceMethods<ViewLikeOpInterface>, NoSideEffect]> {
-  let summary = "memref view operation";
-  let description = [{
-    The "view" operation extracts an N-D contiguous memref with empty layout map
-    with arbitrary element type from a 1-D contiguous memref with empty layout
-    map of i8 element  type. The ViewOp supports the following arguments:
-
-    * A single dynamic byte-shift operand must be specified which represents a
-      a shift of the base 1-D memref pointer from which to create the resulting
-      contiguous memref view with identity layout.
-    * A dynamic size operand that must be specified for each dynamic dimension
-      in the resulting view memref type.
-
-    The "view" operation gives a structured indexing form to a flat 1-D buffer.
-    Unlike "subview" it can perform a type change. The type change behavior
-    requires the op to have special semantics because, e.g. a byte shift of 3
-    cannot be represented as an offset on f64.
-    For now, a "view" op:
-
-    1. Only takes a contiguous source memref with 0 offset and empty layout.
-    2. Must specify a byte_shift operand (in the future, a special integer
-       attribute may be added to support the folded case).
-    3. Returns a contiguous memref with 0 offset and empty layout.
-
-    Example:
-
-    ```mlir
-    // Allocate a flat 1D/i8 memref.
-    %0 = alloc() : memref<2048xi8>
-
-    // ViewOp with dynamic offset and static sizes.
-    %1 = view %0[%offset_1024][] : memref<2048xi8> to memref<64x4xf32>
-
-    // ViewOp with dynamic offset and two dynamic size.
-    %2 = view %0[%offset_1024][%size0, %size1] :
-      memref<2048xi8> to memref<?x4x?xf32>
-    ```
-  }];
-
-  let arguments = (ins MemRefRankOf<[I8], [1]>:$source,
-                   Index:$byte_shift,
-                   Variadic<Index>:$sizes);
-  let results = (outs AnyMemRef);
-
-  let extraClassDeclaration = [{
-    /// The result of a view is always a memref.
-    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
-
-    /// Returns the dynamic sizes for this view operation. This is redundant
-    /// with `sizes` but needed in template implementations. More specifically:
-    /// ```
-    /// template <typename AnyMemRefDefOp>
-    /// bool isMemRefSizeValidSymbol(AnyMemRefDefOp memrefDefOp, unsigned index,
-    ///                              Region *region)
-    /// ```
-    operand_range getDynamicSizes() {
-      return {sizes().begin(), sizes().end()};
-    }
-  }];
-
-  let hasCanonicalizer = 1;
-}
-
-//===----------------------------------------------------------------------===//
 // XOrOp
 //===----------------------------------------------------------------------===//
 
 def XOrOp : IntBinaryOp<"xor", [Commutative]> {
   let summary = "integer binary xor";
   let description = [{
     The `xor` operation takes two operands and returns one result, each of these
     is required to be the same type. This type may be an integer scalar type, a

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

let description = [{
     successor arguments of predecessors be converted. This is achieved by
     rewriting terminators based on the information provided by the
     `BranchOpInterface`.
     As this pass rewrites function operations, it also rewrites the
     corresponding return operations. Other return-like operations that
     implement the `ReturnLike` trait are not rewritten in general, as they
     require that the corresponding parent operation is also rewritten.
     Finally, this pass fails for unknown terminators, as we cannot decide
-    whether they need rewriting. 
+    whether they need rewriting.
   }];
   let constructor = "mlir::createFuncBufferizePass()";
 }
 
 def TensorConstantBufferize : Pass<"tensor-constant-bufferize", "ModuleOp"> {
   let summary = "Bufferize tensor constants.";
   let description = [{
     This pass bufferizes tensor constants.
 
-    This pass needs to be a module pass because it inserts std.global_memref
+    This pass needs to be a module pass because it inserts memref.global
     ops into the module, which cannot be done safely from a function pass due to
     multi-threading. Most other bufferization passes can run in parallel at
     function granularity.
   }];
   let constructor = "mlir::createTensorConstantBufferizePass()";
 }
 
 #endif // MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Vector/VectorTransforms.h

 /// Example (a 2-D vector.transfer_read):
 /// ```
 ///    %1 = vector.transfer_read %0[...], %pad : memref<A...>, vector<...>
 /// ```
 /// is transformed into:
 /// ```
 ///    %1:3 = scf.if (%inBounds) {
 ///      // fastpath, direct cast
-///      memref_cast %A: memref<A...> to compatibleMemRefType
+///      memref.cast %A: memref<A...> to compatibleMemRefType
 ///      scf.yield %view : compatibleMemRefType, index, index
 ///    } else {
 ///      // slowpath, masked vector.transfer or linalg.copy.
-///      memref_cast %alloc: memref<B...> to compatibleMemRefType
+///      memref.cast %alloc: memref<B...> to compatibleMemRefType
 ///      scf.yield %4 : compatibleMemRefType, index, index
 //     }
 ///    %0 = vector.transfer_read %1#0[%1#1, %1#2] {masked = [false ... false]}
 /// ```
 /// where `alloc` is a top of the function alloca'ed buffer of one vector.
 ///
 /// Preconditions:
 ///  1. `xferOp.permutation_map()` must be a minor identity map

mlir/include/mlir/IR/OpDefinition.h

static_assert(!ConcreteType::template hasTrait<ZeroRegion>(),
                   "expected operation to have one or more regions");
     return success();
   }
 };
 
 /// A trait of region holding operations that define a new scope for automatic
 /// allocations, i.e., allocations that are freed when control is transferred
 /// back from the operation's region. Any operations performing such allocations
-/// (for eg. std.alloca) will have their allocations automatically freed at
+/// (for eg. memref.alloca) will have their allocations automatically freed at
 /// their closest enclosing operation with this trait.
 template <typename ConcreteType>
 class AutomaticAllocationScope
     : public TraitBase<ConcreteType, AutomaticAllocationScope> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     static_assert(!ConcreteType::template hasTrait<ZeroRegion>(),
                   "expected operation to have one or more regions");

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMArmNeonDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMArmSVEDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/SDBM/SDBMDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
registry.insert<acc::OpenACCDialect,
                   complex::ComplexDialect,
                   gpu::GPUDialect,
                   LLVM::LLVMAVX512Dialect,
                   LLVM::LLVMDialect,
                   LLVM::LLVMArmNeonDialect,
                   LLVM::LLVMArmSVEDialect,
                   linalg::LinalgDialect,
                   math::MathDialect,
+                  memref::MemRefDialect,
                   scf::SCFDialect,
                   omp::OpenMPDialect,
                   pdl::PDLDialect,
                   pdl_interp::PDLInterpDialect,
                   quant::QuantizationDialect,
                   spirv::SPIRVDialect,
                   StandardOpsDialect,
                   arm_sve::ArmSVEDialect,

mlir/include/mlir/Transforms/Passes.td

let description = [{
     memref types while preserving the original behavior, users of those
     memref types are also modified to incorporate the resulting layout map.
     For instance, an [AffineLoadOp]
     (https://mlir.llvm.org/docs/Dialects/Affine/#affineload-affineloadop)
     will be updated to compose the layout map with with the affine expression
     contained in the op. Operations marked with the [MemRefsNormalizable]
     (https://mlir.llvm.org/docs/Traits/#memrefsnormalizable) trait are
     expected to be normalizable. Supported operations include affine
-    operations, std.alloc, std.dealloc, and std.return.
+    operations, memref.alloc, memref.dealloc, and std.return.
 
     Given an appropriate layout map specified in the code, this transformation
     can express tiled or linearized access to multi-dimensional data
     structures, but will not modify memref types without an explicit layout
     map.
 
     Currently this pass is limited to only modify
     functions where all memref types can be normalized. If a function

mlir/include/mlir/Transforms/Utils.h

 // are used either by passes, optimization sequences, or in turn by other
 // transformation utilities.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_UTILS_H
 #define MLIR_TRANSFORMS_UTILS_H
 
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineMap.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace mlir {
 
 class AffineApplyOp;
LogicalResult replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,
                                        AffineMap indexRemap = AffineMap(),
                                        ArrayRef<Value> extraOperands = {},
                                        ArrayRef<Value> symbolOperands = {},
                                        bool allowNonDereferencingOps = false);
 
 /// Rewrites the memref defined by this alloc op to have an identity layout map
 /// and updates all its indexing uses. Returns failure if any of its uses
 /// escape (while leaving the IR in a valid state).
-LogicalResult normalizeMemRef(AllocOp op);
+LogicalResult normalizeMemRef(memref::AllocOp op);
 
 /// Uses the old memref type map layout and computes the new memref type to have
 /// a new shape and a layout map, where the old layout map has been normalized
 /// to an identity layout map. It returns the old memref in case no
 /// normalization was needed or a failure occurs while transforming the old map
 /// layout to an identity layout map.
 MemRefType normalizeMemRefType(MemRefType memrefType, OpBuilder builder,
                                unsigned numSymbolicOperands);

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 // operations) within a function into their standard If and For equivalent ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 
 #include "../PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"

 public:
   /// This internal class expects arguments to be non-null, checks must be
   /// performed at the call site.
   AffineApplyExpander(OpBuilder &builder, ValueRange dimValues,
                       ValueRange symbolValues, Location loc)
       : builder(builder), dimValues(dimValues), symbolValues(symbolValues),
         loc(loc) {}
 
-  template <typename OpTy> Value buildBinaryExpr(AffineBinaryOpExpr expr) {
+  template <typename OpTy>
+  Value buildBinaryExpr(AffineBinaryOpExpr expr) {
     auto lhs = visit(expr.getLHS());
     auto rhs = visit(expr.getRHS());
     if (!lhs || !rhs)
       return nullptr;
     auto op = builder.create<OpTy>(loc, lhs, rhs);
     return op.getResult();
   }
 
LogicalResult matchAndRewrite(AffineLoadOp op,
     // Build vector.load memref[expandedMap.results].
     rewriter.replaceOpWithNewOp<mlir::LoadOp>(op, op.getMemRef(),
                                               *resultOperands);
     return success();
   }
 };
 
 /// Apply the affine map from an 'affine.prefetch' operation to its operands,
-/// and feed the results to a newly created 'std.prefetch' operation (which
+/// and feed the results to a newly created 'memref.prefetch' operation (which
 /// replaces the original 'affine.prefetch').
 class AffinePrefetchLowering : public OpRewritePattern<AffinePrefetchOp> {
 public:
   using OpRewritePattern<AffinePrefetchOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AffinePrefetchOp op,
                                 PatternRewriter &rewriter) const override {
     // Expand affine map from 'affinePrefetchOp'.
     SmallVector<Value, 8> indices(op.getMapOperands());
     auto resultOperands =
         expandAffineMap(rewriter, op.getLoc(), op.getAffineMap(), indices);
     if (!resultOperands)
       return failure();
 
-    // Build std.prefetch memref[expandedMap.results].
-    rewriter.replaceOpWithNewOp<PrefetchOp>(op, op.memref(), *resultOperands,
-                                            op.isWrite(), op.localityHint(),
-                                            op.isDataCache());
+    // Build memref.prefetch memref[expandedMap.results].
+    rewriter.replaceOpWithNewOp<memref::PrefetchOp>(
+        op, op.memref(), *resultOperands, op.isWrite(), op.localityHint(),
     return success();
   }
 };
 
 /// Apply the affine map from an 'affine.store' operation to its operands, and
-/// feed the results to a newly created 'std.store' operation (which replaces
+/// feed the results to a newly created 'memref.store' operation (which replaces
 /// the original 'affine.store').
 class AffineStoreLowering : public OpRewritePattern<AffineStoreOp> {
 public:
   using OpRewritePattern<AffineStoreOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AffineStoreOp op,
                                 PatternRewriter &rewriter) const override {
     // Expand affine map from 'affineStoreOp'.
     SmallVector<Value, 8> indices(op.getMapOperands());
     auto maybeExpandedMap =
         expandAffineMap(rewriter, op.getLoc(), op.getAffineMap(), indices);
     if (!maybeExpandedMap)
       return failure();
 
-    // Build std.store valueToStore, memref[expandedMap.results].
-    rewriter.replaceOpWithNewOp<mlir::StoreOp>(
+    // Build memref.store valueToStore, memref[expandedMap.results].
+    rewriter.replaceOpWithNewOp<memref::StoreOp>(
         op, op.getValueToStore(), op.getMemRef(), *maybeExpandedMap);
     return success();
   }
 };
 
 /// Apply the affine maps from an 'affine.dma_start' operation to each of their
 /// respective map operands, and feed the results to a newly created
 /// 'std.dma_start' operation (which replaces the original 'affine.dma_start').

 
 namespace {
 class LowerAffinePass : public ConvertAffineToStandardBase<LowerAffinePass> {
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     populateAffineToStdConversionPatterns(patterns, &getContext());
     populateAffineToVectorConversionPatterns(patterns, &getContext());
     ConversionTarget target(getContext());
-    target
-        .addLegalDialect<scf::SCFDialect, StandardOpsDialect, VectorDialect>();
+    target.addLegalDialect<memref::MemRefDialect, scf::SCFDialect,
+                           StandardOpsDialect, VectorDialect>();
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 /// Lowers If and For operations within a function into their lower level CFG
 /// equivalent blocks.
 std::unique_ptr<Pass> mlir::createLowerAffinePass() {
   return std::make_unique<LowerAffinePass>();
 }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

createTypeCanonicalizedMemRefOperands(OpBuilder &b, Location loc,
   res.reserve(operands.size());
   for (auto op : operands) {
     auto memrefType = op.getType().dyn_cast<MemRefType>();
     if (!memrefType) {
       res.push_back(op);
       continue;
     }
     Value cast =
-        b.create<MemRefCastOp>(loc, eraseStridedLayout(memrefType), op);
+        b.create<memref::CastOp>(loc, eraseStridedLayout(memrefType), op);
     res.push_back(cast);
   }
   return res;
 }
 
 LogicalResult mlir::linalg::LinalgOpToLibraryCallRewrite::matchAndRewrite(
     Operation *op, PatternRewriter &rewriter) const {
   // Only LinalgOp for which there is no specialized pattern go through this.

 
 LogicalResult mlir::linalg::CopyTransposeRewrite::matchAndRewrite(
     CopyOp op, PatternRewriter &rewriter) const {
   Value in = op.input(), out = op.output();
 
   // If either inputPerm or outputPerm are non-identities, insert transposes.
   auto inputPerm = op.inputPermutation();
   if (inputPerm.hasValue() && !inputPerm->isIdentity())
-    in = rewriter.create<TransposeOp>(op.getLoc(), in,
+    in = rewriter.create<memref::TransposeOp>(op.getLoc(), in,
                                               AffineMapAttr::get(*inputPerm));
   auto outputPerm = op.outputPermutation();
   if (outputPerm.hasValue() && !outputPerm->isIdentity())
-    out = rewriter.create<TransposeOp>(op.getLoc(), out,
+    out = rewriter.create<memref::TransposeOp>(op.getLoc(), out,
                                                AffineMapAttr::get(*outputPerm));
 
   // If nothing was transposed, fail and let the conversion kick in.
   if (in == op.input() && out == op.output())
     return failure();
 
   auto libraryCallName = getLibraryCallSymbolRef(op, rewriter);
   if (!libraryCallName)
     return failure();
struct ConvertLinalgToStandardPass
     : public ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToStandardPass::runOnOperation() {
   auto module = getOperation();
   ConversionTarget target(getContext());
-  target.addLegalDialect<AffineDialect, scf::SCFDialect, StandardOpsDialect>();
+  target.addLegalDialect<AffineDialect, memref::MemRefDialect, scf::SCFDialect,
+                         StandardOpsDialect>();
   target.addLegalOp<ModuleOp, FuncOp, ModuleTerminatorOp, ReturnOp>();
   target.addLegalOp<linalg::ReshapeOp, linalg::RangeOp>();
   OwningRewritePatternList patterns;
   populateLinalgToStandardConversionPatterns(patterns, &getContext());
   if (failed(applyFullConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertLinalgToStandardPass() {
   return std::make_unique<ConvertLinalgToStandardPass>();
 }

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/GPU/ParallelLoopMapper.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/LoopUtils.h"

 }
 
 void mlir::populateParallelLoopToGPUPatterns(OwningRewritePatternList &patterns,
                                              MLIRContext *ctx) {
   patterns.insert<ParallelToGpuLaunchLowering>(ctx);
 }
 
 void mlir::configureParallelLoopToGPULegality(ConversionTarget &target) {
+  target.addLegalDialect<memref::MemRefDialect>();
   target.addDynamicallyLegalOp<scf::ParallelOp>([](scf::ParallelOp parallelOp) {
     return !parallelOp->getAttr(gpu::getMappingAttrName());
   });
 }

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
void rewrite(Operation *op, ArrayRef<Value> operands,
 
     // Return the final value of the descriptor.
     rewriter.replaceOp(op, {memRefDescriptor});
   }
 };
 
 struct AllocOpLowering : public AllocLikeOpLowering {
   AllocOpLowering(LLVMTypeConverter &converter)
-      : AllocLikeOpLowering(AllocOp::getOperationName(), converter) {}
+      : AllocLikeOpLowering(memref::AllocOp::getOperationName(), converter) {}
 
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
                                           Location loc, Value sizeBytes,
                                           Operation *op) const override {
     // Heap allocations.
-    AllocOp allocOp = cast<AllocOp>(op);
+    memref::AllocOp allocOp = cast<memref::AllocOp>(op);
     MemRefType memRefType = allocOp.getType();
 
     Value alignment;
     if (auto alignmentAttr = allocOp.alignment()) {
       alignment = createIndexConstant(rewriter, loc, *alignmentAttr);
     } else if (!memRefType.getElementType().isSignlessIntOrIndexOrFloat()) {
       // In the case where no alignment is specified, we may want to override
       // `malloc's` behavior. `malloc` typically aligns at the size of the
std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
     }
 
     return std::make_tuple(allocatedPtr, alignedPtr);
   }
 };
 
 struct AlignedAllocOpLowering : public AllocLikeOpLowering {
   AlignedAllocOpLowering(LLVMTypeConverter &converter)
-      : AllocLikeOpLowering(AllocOp::getOperationName(), converter) {}
+      : AllocLikeOpLowering(memref::AllocOp::getOperationName(), converter) {}
 
   /// Returns the memref's element size in bytes.
   // TODO: there are other places where this is used. Expose publicly?
   static unsigned getMemRefEltSizeInBytes(MemRefType memRefType) {
     auto elementType = memRefType.getElementType();
 
     unsigned sizeInBits;
     if (elementType.isIntOrFloat()) {
for (unsigned i = 0, e = type.getRank(); i < e; i++) {
       sizeDivisor = sizeDivisor * type.getDimSize(i);
     }
     return sizeDivisor % factor == 0;
   }
 
   /// Returns the alignment to be used for the allocation call itself.
   /// aligned_alloc requires the allocation size to be a power of two, and the
   /// allocation size to be a multiple of alignment,
-  int64_t getAllocationAlignment(AllocOp allocOp) const {
+  int64_t getAllocationAlignment(memref::AllocOp allocOp) const {
     if (Optional<uint64_t> alignment = allocOp.alignment())
       return *alignment;
 
     // Whenever we don't have alignment set, we will use an alignment
     // consistent with the element type; since the allocation size has to be a
     // power of two, we will bump to the next power of two if it already isn't.
     auto eltSizeBytes = getMemRefEltSizeInBytes(allocOp.getType());
     return std::max(kMinAlignedAllocAlignment,
                     llvm::PowerOf2Ceil(eltSizeBytes));
   }
 
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
                                           Location loc, Value sizeBytes,
                                           Operation *op) const override {
     // Heap allocations.
-    AllocOp allocOp = cast<AllocOp>(op);
+    memref::AllocOp allocOp = cast<memref::AllocOp>(op);
     MemRefType memRefType = allocOp.getType();
     int64_t alignment = getAllocationAlignment(allocOp);
     Value allocAlignment = createIndexConstant(rewriter, loc, alignment);
 
     // aligned_alloc requires size to be a multiple of alignment; we will pad
     // the size to the next multiple if necessary.
     if (!isMemRefSizeMultipleOf(memRefType, alignment))
       sizeBytes = createAligned(rewriter, loc, sizeBytes, allocAlignment);
struct AlignedAllocOpLowering : public AllocLikeOpLowering {
   static constexpr uint64_t kMinAlignedAllocAlignment = 16UL;
 };
 
 // Out of line definition, required till C++17.
 constexpr uint64_t AlignedAllocOpLowering::kMinAlignedAllocAlignment;
 
 struct AllocaOpLowering : public AllocLikeOpLowering {
   AllocaOpLowering(LLVMTypeConverter &converter)
-      : AllocLikeOpLowering(AllocaOp::getOperationName(), converter) {}
+      : AllocLikeOpLowering(memref::AllocaOp::getOperationName(), converter) {}
 
   /// Allocates the underlying buffer using the right call. `allocatedBytePtr`
   /// is set to null for stack allocations. `accessAlignment` is set if
   /// alignment is needed post allocation (for eg. in conjunction with malloc).
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
                                           Location loc, Value sizeBytes,
                                           Operation *op) const override {
 
     // With alloca, one gets a pointer to the element type right away.
     // For stack allocations.
-    auto allocaOp = cast<AllocaOp>(op);
+    auto allocaOp = cast<memref::AllocaOp>(op);
     auto elementPtrType = this->getElementPtrType(allocaOp.getType());
 
     auto allocatedElementPtr = rewriter.create<LLVM::AllocaOp>(
         loc, elementPtrType, sizeBytes,
         allocaOp.alignment() ? *allocaOp.alignment() : 0);
 
     return std::make_tuple(allocatedElementPtr, allocatedElementPtr);
   }

 
 struct CallIndirectOpLowering : public CallOpInterfaceLowering<CallIndirectOp> {
   using Super::Super;
 };
 
 // A `dealloc` is converted into a call to `free` on the underlying data buffer.
 // The memref descriptor being an SSA value, there is no need to clean it up
 // in any way.
-struct DeallocOpLowering : public ConvertOpToLLVMPattern<DeallocOp> {
-  using ConvertOpToLLVMPattern<DeallocOp>::ConvertOpToLLVMPattern;
+struct DeallocOpLowering : public ConvertOpToLLVMPattern<memref::DeallocOp> {
+  using ConvertOpToLLVMPattern<memref::DeallocOp>::ConvertOpToLLVMPattern;
 
   explicit DeallocOpLowering(LLVMTypeConverter &converter)
-      : ConvertOpToLLVMPattern<DeallocOp>(converter) {}
+      : ConvertOpToLLVMPattern<memref::DeallocOp>(converter) {}
 
   LogicalResult
-  matchAndRewrite(DeallocOp op, ArrayRef<Value> operands,
+  matchAndRewrite(memref::DeallocOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     assert(operands.size() == 1 && "dealloc takes one operand");
-    DeallocOp::Adaptor transformed(operands);
+    memref::DeallocOp::Adaptor transformed(operands);
 
     // Insert the `free` declaration if it is not already present.
     auto freeFunc = LLVM::lookupOrCreateFreeFn(op->getParentOfType<ModuleOp>());
     MemRefDescriptor memref(transformed.memref());
     Value casted = rewriter.create<LLVM::BitcastOp>(
         op.getLoc(), getVoidPtrType(),
         memref.allocatedPtr(rewriter, op.getLoc()));
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
         op, TypeRange(), rewriter.getSymbolRefAttr(freeFunc), casted);
     return success();
   }
 };
 
 /// Returns the LLVM type of the global variable given the memref type `type`.
 static Type convertGlobalMemrefTypeToLLVM(MemRefType type,
                                           LLVMTypeConverter &typeConverter) {
   // LLVM type for a global memref will be a multi-dimension array. For
   // declarations or uninitialized global memrefs, we can potentially flatten
-  // this to a 1D array. However, for global_memref's with an initial value,
+  // this to a 1D array. However, for memref.global's with an initial value,
   // we do not intend to flatten the ElementsAttribute when going from std ->
   // LLVM dialect, so the LLVM type needs to me a multi-dimension array.
   Type elementType = unwrap(typeConverter.convertType(type.getElementType()));
   Type arrayTy = elementType;
   // Shape has the outermost dim at index 0, so need to walk it backwards
   for (int64_t dim : llvm::reverse(type.getShape()))
     arrayTy = LLVM::LLVMArrayType::get(arrayTy, dim);
   return arrayTy;
 }
 
 /// GlobalMemrefOp is lowered to a LLVM Global Variable.
-struct GlobalMemrefOpLowering : public ConvertOpToLLVMPattern<GlobalMemrefOp> {
-  using ConvertOpToLLVMPattern<GlobalMemrefOp>::ConvertOpToLLVMPattern;
+struct GlobalMemrefOpLowering
+    : public ConvertOpToLLVMPattern<memref::GlobalOp> {
+  using ConvertOpToLLVMPattern<memref::GlobalOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(GlobalMemrefOp global, ArrayRef<Value> operands,
+  matchAndRewrite(memref::GlobalOp global, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     MemRefType type = global.type().cast<MemRefType>();
     if (!isConvertibleAndHasIdentityMaps(type))
       return failure();
 
     Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
 
     LLVM::Linkage linkage =
struct GlobalMemrefOpLowering
   }
 };
 
 /// GetGlobalMemrefOp is lowered into a Memref descriptor with the pointer to
 /// the first element stashed into the descriptor. This reuses
 /// `AllocLikeOpLowering` to reuse the Memref descriptor construction.
 struct GetGlobalMemrefOpLowering : public AllocLikeOpLowering {
   GetGlobalMemrefOpLowering(LLVMTypeConverter &converter)
-      : AllocLikeOpLowering(GetGlobalMemrefOp::getOperationName(), converter) {}
+      : AllocLikeOpLowering(memref::GetGlobalOp::getOperationName(),
+                            converter) {}
 
-  /// Buffer "allocation" for get_global_memref op is getting the address of
+  /// Buffer "allocation" for memref.get_global op is getting the address of
   /// the global variable referenced.
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
                                           Location loc, Value sizeBytes,
                                           Operation *op) const override {
-    auto getGlobalOp = cast<GetGlobalMemrefOp>(op);
+    auto getGlobalOp = cast<memref::GetGlobalOp>(op);
     MemRefType type = getGlobalOp.result().getType().cast<MemRefType>();
     unsigned memSpace = type.getMemorySpace();
 
     Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
     auto addressOf = rewriter.create<LLVM::AddressOfOp>(
         loc, LLVM::LLVMPointerType::get(arrayTy, memSpace), getGlobalOp.name());
 
     // Get the address of the first element in the array by creating a GEP with
     // the address of the GV as the base, and (rank + 1) number of 0 indices.
     Type elementType =
         unwrap(typeConverter->convertType(type.getElementType()));
     Type elementPtrType = LLVM::LLVMPointerType::get(elementType, memSpace);
 
     SmallVector<Value, 4> operands = {addressOf};
     operands.insert(operands.end(), type.getRank() + 1,
                     createIndexConstant(rewriter, loc, 0));
     auto gep = rewriter.create<LLVM::GEPOp>(loc, elementPtrType, operands);
 
-    // We do not expect the memref obtained using `get_global_memref` to be
+    // We do not expect the memref obtained using `memref.get_global` to be
     // ever deallocated. Set the allocated pointer to be known bad value to
     // help debug if that ever happens.
     auto intPtrType = getIntPtrType(memSpace);
     Value deadBeefConst =
         createIndexAttrConstant(rewriter, op->getLoc(), intPtrType, 0xdeadbeef);
     auto deadBeefPtr =
         rewriter.create<LLVM::IntToPtrOp>(loc, elementPtrType, deadBeefConst);
 
return handleMultidimensionalVectors(
           auto sqrt =
               rewriter.create<LLVM::SqrtOp>(loc, llvm1DVectorTy, operands[0]);
           return rewriter.create<LLVM::FDivOp>(loc, llvm1DVectorTy, one, sqrt);
         },
         rewriter);
   }
 };
 
-struct MemRefCastOpLowering : public ConvertOpToLLVMPattern<MemRefCastOp> {
-  using ConvertOpToLLVMPattern<MemRefCastOp>::ConvertOpToLLVMPattern;
+struct MemRefCastOpLowering : public ConvertOpToLLVMPattern<memref::CastOp> {
+  using ConvertOpToLLVMPattern<memref::CastOp>::ConvertOpToLLVMPattern;
 
-  LogicalResult match(MemRefCastOp memRefCastOp) const override {
+  LogicalResult match(memref::CastOp memRefCastOp) const override {
     Type srcType = memRefCastOp.getOperand().getType();
     Type dstType = memRefCastOp.getType();
 
-    // MemRefCastOp reduce to bitcast in the ranked MemRef case and can be used
-    // for type erasure. For now they must preserve underlying element type and
-    // require source and result type to have the same rank. Therefore, perform
-    // a sanity check that the underlying structs are the same. Once op
+    // memref::CastOp reduce to bitcast in the ranked MemRef case and can be
+    // used for type erasure. For now they must preserve underlying element type
+    // and require source and result type to have the same rank. Therefore,
+    // perform a sanity check that the underlying structs are the same. Once op
     // semantics are relaxed we can revisit.
     if (srcType.isa<MemRefType>() && dstType.isa<MemRefType>())
       return success(typeConverter->convertType(srcType) ==
                      typeConverter->convertType(dstType));
 
     // At least one of the operands is unranked type
     assert(srcType.isa<UnrankedMemRefType>() ||
            dstType.isa<UnrankedMemRefType>());
 
     // Unranked to unranked cast is disallowed
     return !(srcType.isa<UnrankedMemRefType>() &&
              dstType.isa<UnrankedMemRefType>())
                ? success()
                : failure();
   }
 
-  void rewrite(MemRefCastOp memRefCastOp, ArrayRef<Value> operands,
+  void rewrite(memref::CastOp memRefCastOp, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const override {
-    MemRefCastOp::Adaptor transformed(operands);
+    memref::CastOp::Adaptor transformed(operands);
 
     auto srcType = memRefCastOp.getOperand().getType();
     auto dstType = memRefCastOp.getType();
     auto targetStructType = typeConverter->convertType(memRefCastOp.getType());
     auto loc = memRefCastOp.getLoc();
 
     // For ranked/ranked case, just keep the original descriptor.
     if (srcType.isa<MemRefType>() && dstType.isa<MemRefType>())
Value dataPtr =
                              transformed.indices(), rewriter);
     rewriter.replaceOpWithNewOp<LLVM::LoadOp>(loadOp, dataPtr);
     return success();
   }
 };
 
 // Store operation is lowered to obtaining a pointer to the indexed element,
 // and storing the given value to it.
-struct StoreOpLowering : public LoadStoreOpLowering<StoreOp> {
+struct StoreOpLowering : public LoadStoreOpLowering<memref::StoreOp> {
   using Base::Base;
 
   LogicalResult
-  matchAndRewrite(StoreOp op, ArrayRef<Value> operands,
+  matchAndRewrite(memref::StoreOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = op.getMemRefType();
-    StoreOp::Adaptor transformed(operands);
+    memref::StoreOp::Adaptor transformed(operands);
 
     Value dataPtr =
         getStridedElementPtr(op.getLoc(), type, transformed.memref(),
                              transformed.indices(), rewriter);
     rewriter.replaceOpWithNewOp<LLVM::StoreOp>(op, transformed.value(),
                                                dataPtr);
     return success();
   }
 };
 
 // The prefetch operation is lowered in a way similar to the load operation
 // except that the llvm.prefetch operation is used for replacement.
-struct PrefetchOpLowering : public LoadStoreOpLowering<PrefetchOp> {
+struct PrefetchOpLowering : public LoadStoreOpLowering<memref::PrefetchOp> {
   using Base::Base;
 
   LogicalResult
-  matchAndRewrite(PrefetchOp prefetchOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::PrefetchOp prefetchOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    PrefetchOp::Adaptor transformed(operands);
+    memref::PrefetchOp::Adaptor transformed(operands);
     auto type = prefetchOp.getMemRefType();
     auto loc = prefetchOp.getLoc();
 
     Value dataPtr = getStridedElementPtr(loc, type, transformed.memref(),
                                          transformed.indices(), rewriter);
 
     // Replace with llvm.prefetch.
     auto llvmI32Type = typeConverter->convertType(rewriter.getIntegerType(32));

 
 /// Conversion pattern that transforms a transpose op into:
 ///   1. A function entry `alloca` operation to allocate a ViewDescriptor.
 ///   2. A load of the ViewDescriptor from the pointer allocated in 1.
 ///   3. Updates to the ViewDescriptor to introduce the data ptr, offset, size
 ///      and stride. Size and stride are permutations of the original values.
 ///   4. A store of the resulting ViewDescriptor to the alloca'ed pointer.
 /// The transpose op is replaced by the alloca'ed pointer.
-class TransposeOpLowering : public ConvertOpToLLVMPattern<TransposeOp> {
+class TransposeOpLowering : public ConvertOpToLLVMPattern<memref::TransposeOp> {
 public:
-  using ConvertOpToLLVMPattern<TransposeOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern<memref::TransposeOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(TransposeOp transposeOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::TransposeOp transposeOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = transposeOp.getLoc();
-    TransposeOpAdaptor adaptor(operands);
+    memref::TransposeOpAdaptor adaptor(operands);
     MemRefDescriptor viewMemRef(adaptor.in());
 
     // No permutation, early exit.
     if (transposeOp.permutation().isIdentity())
       return rewriter.replaceOp(transposeOp, {viewMemRef}), success();
 
     auto targetMemRef = MemRefDescriptor::undef(
         rewriter, loc, typeConverter->convertType(transposeOp.getShapedType()));
public:
   }
 };
 
 /// Conversion pattern that transforms an op into:
 ///   1. An `llvm.mlir.undef` operation to create a memref descriptor
 ///   2. Updates to the descriptor to introduce the data ptr, offset, size
 ///      and stride.
 /// The view op is replaced by the descriptor.
-struct ViewOpLowering : public ConvertOpToLLVMPattern<ViewOp> {
-  using ConvertOpToLLVMPattern<ViewOp>::ConvertOpToLLVMPattern;
+struct ViewOpLowering : public ConvertOpToLLVMPattern<memref::ViewOp> {
+  using ConvertOpToLLVMPattern<memref::ViewOp>::ConvertOpToLLVMPattern;
 
   // Build and return the value for the idx^th shape dimension, either by
   // returning the constant shape dimension or counting the proper dynamic size.
   Value getSize(ConversionPatternRewriter &rewriter, Location loc,
                 ArrayRef<int64_t> shape, ValueRange dynamicSizes,
                 unsigned idx) const {
     assert(idx < shape.size());
     if (!ShapedType::isDynamic(shape[idx]))
if (nextSize)
       return runningStride
                  ? rewriter.create<LLVM::MulOp>(loc, runningStride, nextSize)
                  : nextSize;
     assert(!runningStride);
     return createIndexConstant(rewriter, loc, 1);
   }
 
   LogicalResult
-  matchAndRewrite(ViewOp viewOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::ViewOp viewOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = viewOp.getLoc();
-    ViewOpAdaptor adaptor(operands);
+    memref::ViewOpAdaptor adaptor(operands);
 
     auto viewMemRefType = viewOp.getType();
     auto targetElementTy =
         typeConverter->convertType(viewMemRefType.getElementType());
     auto targetDescTy = typeConverter->convertType(viewMemRefType);
     if (!targetDescTy || !targetElementTy ||
         !LLVM::isCompatibleType(targetElementTy) ||
         !LLVM::isCompatibleType(targetDescTy))

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

 //===- LegalizeStandardForSPIRV.cpp - Legalize ops for SPIR-V lowering ----===//
 //
 // 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 transformation pass legalizes operations before the conversion to SPIR-V
 // dialect to handle ops that cannot be lowered directly.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRV.h"
 #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 /// Helpers to access the memref operand for each op.
 static Value getMemRefOperand(LoadOp op) { return op.memref(); }
 
 static Value getMemRefOperand(vector::TransferReadOp op) { return op.source(); }
 
-static Value getMemRefOperand(StoreOp op) { return op.memref(); }
+static Value getMemRefOperand(memref::StoreOp op) { return op.memref(); }
 
 static Value getMemRefOperand(vector::TransferWriteOp op) {
   return op.source();
 }
 
 namespace {
 /// Merges subview operation with load/transferRead operation.
 template <typename OpTy>
void LoadOpOfSubViewFolder<vector::TransferReadOp>::replaceOp(
     vector::TransferReadOp loadOp, SubViewOp subViewOp,
     ArrayRef<Value> sourceIndices, PatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
       loadOp, loadOp.getVectorType(), subViewOp.source(), sourceIndices,
       loadOp.permutation_map(), loadOp.padding(), loadOp.maskedAttr());
 }
 
 template <>
-void StoreOpOfSubViewFolder<StoreOp>::replaceOp(
-    StoreOp storeOp, SubViewOp subViewOp, ArrayRef<Value> sourceIndices,
+void StoreOpOfSubViewFolder<memref::StoreOp>::replaceOp(
+    memref::StoreOp storeOp, SubViewOp subViewOp, ArrayRef<Value> sourceIndices,
     PatternRewriter &rewriter) const {
-  rewriter.replaceOpWithNewOp<StoreOp>(storeOp, storeOp.value(),
-                                       subViewOp.source(), sourceIndices);
+  rewriter.replaceOpWithNewOp<memref::StoreOp>(
+      storeOp, storeOp.value(), subViewOp.source(), sourceIndices);
 }
 
 template <>
 void StoreOpOfSubViewFolder<vector::TransferWriteOp>::replaceOp(
     vector::TransferWriteOp tranferWriteOp, SubViewOp subViewOp,
     ArrayRef<Value> sourceIndices, PatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
       tranferWriteOp, tranferWriteOp.vector(), subViewOp.source(),

 //===----------------------------------------------------------------------===//
 // Hook for adding patterns.
 //===----------------------------------------------------------------------===//
 
 void mlir::populateStdLegalizationPatternsForSPIRVLowering(
     MLIRContext *context, OwningRewritePatternList &patterns) {
   patterns.insert<LoadOpOfSubViewFolder<LoadOp>,
                   LoadOpOfSubViewFolder<vector::TransferReadOp>,
-                  StoreOpOfSubViewFolder<StoreOp>,
+                  StoreOpOfSubViewFolder<memref::StoreOp>,
                   StoreOpOfSubViewFolder<vector::TransferWriteOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Pass for testing just the legalization patterns.
 //===----------------------------------------------------------------------===//
 
 namespace {

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

 //===- StandardToSPIRV.cpp - Standard to SPIR-V 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 patterns to convert standard dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/SetVector.h"

 // normal RewritePattern.
 
 namespace {
 
 /// Converts an allocation operation to SPIR-V. Currently only supports lowering
 /// to Workgroup memory when the size is constant.  Note that this pattern needs
 /// to be applied in a pass that runs at least at spv.module scope since it wil
 /// ladd global variables into the spv.module.
-class AllocOpPattern final : public OpConversionPattern<AllocOp> {
+class AllocOpPattern final : public OpConversionPattern<memref::AllocOp> {
 public:
-  using OpConversionPattern<AllocOp>::OpConversionPattern;
+  using OpConversionPattern<memref::AllocOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AllocOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(memref::AllocOp operation, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     MemRefType allocType = operation.getType();
     if (!isAllocationSupported(allocType))
       return operation.emitError("unhandled allocation type");
 
     // Get the SPIR-V type for the allocation.
     Type spirvType = getTypeConverter()->convertType(allocType);
 
matchAndRewrite(memref::AllocOp operation, ArrayRef<Value> operands,
     // Get pointer to global variable at the current scope.
     rewriter.replaceOpWithNewOp<spirv::AddressOfOp>(operation, varOp);
     return success();
   }
 };
 
 /// Removed a deallocation if it is a supported allocation. Currently only
 /// removes deallocation if the memory space is workgroup memory.
-class DeallocOpPattern final : public OpConversionPattern<DeallocOp> {
+class DeallocOpPattern final : public OpConversionPattern<memref::DeallocOp> {
 public:
-  using OpConversionPattern<DeallocOp>::OpConversionPattern;
+  using OpConversionPattern<memref::DeallocOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(DeallocOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(memref::DeallocOp operation, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     MemRefType deallocType = operation.memref().getType().cast<MemRefType>();
     if (!isAllocationSupported(deallocType))
       return operation.emitError("unhandled deallocation type");
     rewriter.eraseOp(operation);
     return success();
   }
 };

 class SelectOpPattern final : public OpConversionPattern<SelectOp> {
 public:
   using OpConversionPattern<SelectOp>::OpConversionPattern;
   LogicalResult
   matchAndRewrite(SelectOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Converts std.store to spv.Store on integers.
-class IntStoreOpPattern final : public OpConversionPattern<StoreOp> {
+/// Converts memref.store to spv.Store on integers.
+class IntStoreOpPattern final : public OpConversionPattern<memref::StoreOp> {
 public:
-  using OpConversionPattern<StoreOp>::OpConversionPattern;
+  using OpConversionPattern<memref::StoreOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::StoreOp storeOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Converts std.store to spv.Store.
-class StoreOpPattern final : public OpConversionPattern<StoreOp> {
+/// Converts memref.store to spv.Store.
+class StoreOpPattern final : public OpConversionPattern<memref::StoreOp> {
 public:
-  using OpConversionPattern<StoreOp>::OpConversionPattern;
+  using OpConversionPattern<memref::StoreOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::StoreOp storeOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.zexti to spv.Select if the type of source is i1 or vector of
 /// i1.
 class ZeroExtendI1Pattern final : public OpConversionPattern<ZeroExtendIOp> {
 public:
   using OpConversionPattern<ZeroExtendIOp>::OpConversionPattern;
SelectOpPattern::matchAndRewrite(SelectOp op, ArrayRef<Value> operands,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-IntStoreOpPattern::matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
+IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp,
+                                   ArrayRef<Value> operands,
                                    ConversionPatternRewriter &rewriter) const {
-  StoreOpAdaptor storeOperands(operands);
+  memref::StoreOpAdaptor storeOperands(operands);
   auto memrefType = storeOp.memref().getType().cast<MemRefType>();
   if (!memrefType.getElementType().isSignlessInteger())
     return failure();
 
   auto loc = storeOp.getLoc();
   auto &typeConverter = *getTypeConverter<SPIRVTypeConverter>();
   spirv::AccessChainOp accessChainOp =
       spirv::getElementPtr(typeConverter, memrefType, storeOperands.memref(),
IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp,
 
   assert(accessChainOp.use_empty());
   rewriter.eraseOp(accessChainOp);
 
   return success();
 }
 
 LogicalResult
-StoreOpPattern::matchAndRewrite(StoreOp storeOp, ArrayRef<Value> operands,
+StoreOpPattern::matchAndRewrite(memref::StoreOp storeOp,
+                                ArrayRef<Value> operands,
                                 ConversionPatternRewriter &rewriter) const {
-  StoreOpAdaptor storeOperands(operands);
+  memref::StoreOpAdaptor storeOperands(operands);
   auto memrefType = storeOp.memref().getType().cast<MemRefType>();
   if (memrefType.getElementType().isSignlessInteger())
     return failure();
   auto storePtr =
       spirv::getElementPtr(*getTypeConverter<SPIRVTypeConverter>(), memrefType,
                            storeOperands.memref(), storeOperands.indices(),
                            storeOp.getLoc(), rewriter);
   rewriter.replaceOpWithNewOp<spirv::StoreOp>(storeOp, storePtr,

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

 static Value setAllocAtFunctionEntry(MemRefType memRefMinorVectorType,
                                      Operation *op) {
   auto &b = ScopedContext::getBuilderRef();
   OpBuilder::InsertionGuard guard(b);
   Operation *scope =
       op->getParentWithTrait<OpTrait::AutomaticAllocationScope>();
   assert(scope && "Expected op to be inside automatic allocation scope");
   b.setInsertionPointToStart(&scope->getRegion(0).front());
-  Value res = std_alloca(memRefMinorVectorType);
+  Value res = memref_alloca(memRefMinorVectorType);
   return res;
 }
 
 template <>
 LogicalResult NDTransferOpHelper<TransferReadOp>::doReplace() {
   Value alloc, result;
   if (options.unroll)
     result = std_splat(vectorType, xferOp.padding());
if (inBoundsCondition) {
             Value vector = load1DVector(majorIvsPlusOffsets);
             // 3.a. If `options.unroll` is true, insert the 1-D vector in the
             // aggregate. We must yield and merge with the `else` branch.
             if (options.unroll) {
               vector = vector_insert(vector, result, majorIvs);
               return {vector};
             }
             // 3.b. Otherwise, just go through the temporary `alloc`.
-            std_store(vector, alloc, majorIvs);
+            memref_store(vector, alloc, majorIvs);
             return {};
           },
           [&]() -> scf::ValueVector {
             Value vector = std_splat(minorVectorType, xferOp.padding());
             // 3.c. If `options.unroll` is true, insert the 1-D vector in the
             // aggregate. We must yield and merge with the `then` branch.
             if (options.unroll) {
               vector = vector_insert(vector, result, majorIvs);
               return {vector};
             }
             // 3.d. Otherwise, just go through the temporary `alloc`.
-            std_store(vector, alloc, majorIvs);
+            memref_store(vector, alloc, majorIvs);
             return {};
           });
 
       if (!resultType.empty())
         result = *ifResults.begin();
     } else {
       // 4. Guaranteed in-bounds, progressively lower to a 1-D transfer read.
       Value loaded1D = load1DVector(majorIvsPlusOffsets);
       // 5.a. If `options.unroll` is true, insert the 1-D vector in the
       // aggregate.
       if (options.unroll)
         result = vector_insert(loaded1D, result, majorIvs);
       // 5.b. Otherwise, just go through the temporary `alloc`.
       else
-        std_store(loaded1D, alloc, majorIvs);
+        memref_store(loaded1D, alloc, majorIvs);
     }
   });
 
   assert((!options.unroll ^ (bool)result) &&
          "Expected resulting Value iff unroll");
   if (!result)
     result = std_load(vector_type_cast(MemRefType::get({}, vectorType), alloc));
   rewriter.replaceOp(op, result);
 
   return success();
 }
 
 template <>
 LogicalResult NDTransferOpHelper<TransferWriteOp>::doReplace() {
   Value alloc;
   if (!options.unroll) {
     alloc = setAllocAtFunctionEntry(memRefMinorVectorType, op);
-    std_store(xferOp.vector(),
+    memref_store(xferOp.vector(),
                  vector_type_cast(MemRefType::get({}, vectorType), alloc));
   }
 
   emitLoops([&](ValueRange majorIvs, ValueRange leadingOffsets,
                 ValueRange majorOffsets, ValueRange minorOffsets,
                 const MemRefBoundsCapture &memrefBounds) {
     // Lower to 1-D vector_transfer_write and let recursion handle it.
     auto emitTransferWrite = [&](ValueRange majorIvsPlusOffsets) {
       SmallVector<Value, 8> indexing;
LogicalResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(
   steps.reserve(vectorBoundsCapture.getSteps().size());
   for (auto step : vectorBoundsCapture.getSteps())
     steps.push_back(std_constant_index(step));
 
   // 2. Emit alloc-store-copy-dealloc.
   Value tmp = setAllocAtFunctionEntry(tmpMemRefType(transfer), transfer);
   StdIndexedValue local(tmp);
   Value vec = vector_type_cast(tmp);
-  std_store(vectorValue, vec);
+  memref_store(vectorValue, vec);
   loopNestBuilder(lbs, ubs, steps, [&](ValueRange loopIvs) {
     auto ivsStorage = llvm::to_vector<8>(loopIvs);
     // Swap the ivsStorage which will reorder memory accesses.
     if (coalescedIdx >= 0)
       std::swap(ivsStorage.back(), ivsStorage[coalescedIdx]);
 
     ArrayRef<Value> ivs(ivsStorage);
     Value pos =

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 //===- AffineOps.cpp - MLIR Affine Operations -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/InliningUtils.h"
static bool isDimOpValidSymbol(DimOp dimOp, Region *region) {
 
   // The dim op is also okay if its operand memref/tensor is a view/subview
   // whose corresponding size is a valid symbol.
   Optional<int64_t> index = dimOp.getConstantIndex();
   assert(index.hasValue() &&
          "expect only `dim` operations with a constant index");
   int64_t i = index.getValue();
   return TypeSwitch<Operation *, bool>(dimOp.memrefOrTensor().getDefiningOp())
-      .Case<ViewOp, SubViewOp, AllocOp>(
+      .Case<memref::ViewOp, SubViewOp, memref::AllocOp>(
           [&](auto op) { return isMemRefSizeValidSymbol(op, i, region); })
       .Default([](Operation *) { return false; });
 }
 
 // A value can be used as a symbol (at all its use sites) iff it meets one of
 // the following conditions:
 // *) It is a constant.
 // *) Its defining op or block arg appearance is immediately enclosed by an op
void AffineApplyOp::getCanonicalizationPatterns(
   results.insert<SimplifyAffineOp<AffineApplyOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Common canonicalization pattern support logic
 //===----------------------------------------------------------------------===//
 
 /// This is a common class used for patterns of the form
-/// "someop(memrefcast) -> someop".  It folds the source of any memref_cast
+/// "someop(memrefcast) -> someop".  It folds the source of any memref.cast
 /// into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {
   bool folded = false;
   for (OpOperand &operand : op->getOpOperands()) {
-    auto cast = operand.get().getDefiningOp<MemRefCastOp>();
+    auto cast = operand.get().getDefiningOp<memref::CastOp>();
     if (cast && !cast.getOperand().getType().isa<UnrankedMemRefType>()) {
       operand.set(cast.getOperand());
       folded = true;
     }
   }
   return success(folded);
 }
 

mlir/lib/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(ArmNeon)
 add_subdirectory(ArmSVE)
 add_subdirectory(Async)
 add_subdirectory(AVX512)
 add_subdirectory(Complex)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(Math)
+add_subdirectory(MemRef)
 add_subdirectory(OpenACC)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)
 add_subdirectory(PDLInterp)
 add_subdirectory(Quant)
 add_subdirectory(SCF)
 add_subdirectory(SDBM)
 add_subdirectory(Shape)

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

 //===- AllReduceLowering.cpp - Implementation of all-reduce lowering ------===//
 //
 // 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 in-dialect lowering of the all-reduce op to a block of
 // simpler instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/GPU/Passes.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
void rewrite() {
     // Add workgroup buffer to parent function for intermediate result.
     Value buffer = createWorkgroupBuffer();
 
     // Write the intermediate results to workgroup memory, using the first lane
     // of each subgroup.
     createPredicatedBlock(isFirstLane, [&] {
       Value subgroupId = getDivideBySubgroupSize(invocationIdx);
       Value index = create<IndexCastOp>(indexType, subgroupId);
-      create<StoreOp>(subgroupReduce, buffer, index);
+      create<memref::StoreOp>(subgroupReduce, buffer, index);
     });
     create<gpu::BarrierOp>();
 
     // Compute number of active subgroups.
     Value biasedBlockSize =
         create<AddIOp>(int32Type, workgroupSize, subgroupMask);
     Value numSubgroups = getDivideBySubgroupSize(biasedBlockSize);
     Value isValidSubgroup =
         create<CmpIOp>(CmpIPredicate::slt, invocationIdx, numSubgroups);
 
     // Use the first numSubgroups invocations to reduce the intermediate results
     // from workgroup memory. The final result is written to workgroup memory
     // again.
     Value zero = create<ConstantIndexOp>(0);
     createPredicatedBlock(isValidSubgroup, [&] {
       Value index = create<IndexCastOp>(indexType, invocationIdx);
       Value value = create<LoadOp>(valueType, buffer, index);
       Value result =
           createSubgroupReduce(numSubgroups, laneId, value, accumFactory);
-      create<StoreOp>(result, buffer, zero);
+      create<memref::StoreOp>(result, buffer, zero);
     });
 
     // Synchronize workgroup and load result from workgroup memory.
     create<gpu::BarrierOp>();
     Value result = create<LoadOp>(valueType, buffer, zero);
 
     rewriter.replaceOp(reduceOp, result);
   }
 
 private:
   // Shortcut to create an op from rewriter using loc as the first argument.
-  template <typename T, typename... Args> T create(Args... args) {
+  template <typename T, typename... Args>
+  T create(Args... args) {
     return rewriter.create<T>(loc, std::forward<Args>(args)...);
   }
 
   // Creates dimension op of type T, with the result casted to int32.
-  template <typename T> Value getDimOp(StringRef dimension) {
+  template <typename T>
+  Value getDimOp(StringRef dimension) {
     Value dim = create<T>(indexType, rewriter.getStringAttr(dimension));
     return create<IndexCastOp>(int32Type, dim);
   }
 
   /// Adds type to funcOp's workgroup attributions.
   Value createWorkgroupBuffer() {
     int workgroupMemoryAddressSpace =
         gpu::GPUDialect::getWorkgroupAddressSpace();
if (opName == "min") {
       return isFloatingPoint
                  ? getCmpFactory<CmpFOp, CmpFPredicate, CmpFPredicate::ULT>()
                  : getCmpFactory<CmpIOp, CmpIPredicate, CmpIPredicate::ult>();
     }
     return AccumulatorFactory();
   }
 
   /// Returns an accumulator factory that creates an op of type T.
-  template <typename T> AccumulatorFactory getFactory() {
+  template <typename T>
+  AccumulatorFactory getFactory() {
     return [&](Value lhs, Value rhs) {
       return create<T>(lhs.getType(), lhs, rhs);
     };
   }
 
   /// Returns an accumulator for comparison such as min, max. T is the type
   /// of the compare op.
   template <typename T, typename PredicateEnum, PredicateEnum predicate>

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

add_mlir_dialect_library(MLIRLinalg
   MLIRLinalgStructuredOpsIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffine
   MLIRIR
   MLIRSideEffectInterfaces
   MLIRViewLikeInterface
   MLIRStandard
+  MLIRMemRef
   MLIRTensor
   )

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static void dispatchIndexOpFoldResult(OpFoldResult ofr,
   APInt apInt = ofr.dyn_cast<Attribute>().cast<IntegerAttr>().getValue();
   staticVec.push_back(apInt.getSExtValue());
 }
 
 /// This is a common class used for patterns of the form
 /// ```
 ///    someop(memrefcast) -> someop
 /// ```
-/// It folds the source of the memref_cast into the root operation directly.
+/// It folds the source of the memref.cast into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {
   bool folded = false;
   for (OpOperand &operand : op->getOpOperands()) {
-    auto castOp = operand.get().getDefiningOp<MemRefCastOp>();
-    if (castOp && canFoldIntoConsumerOp(castOp)) {
+    auto castOp = operand.get().getDefiningOp<memref::CastOp>();
+    if (castOp && memref::CastOp::canFoldIntoConsumerOp(castOp)) {
       operand.set(castOp.getOperand());
       folded = true;
     }
   }
   return success(folded);
 }
 
 //===----------------------------------------------------------------------===//

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

 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace ::mlir;
 using namespace ::mlir::linalg;
 
 static Value cloneMemref(Location loc, Value memref, OpBuilder &b) {
   auto memrefType = memref.getType().cast<MemRefType>();
-  auto alloc =
-      b.create<AllocOp>(loc, memrefType, getDynOperands(loc, memref, b));
+  auto alloc = b.create<memref::AllocOp>(loc, memrefType,
+                                         getDynOperands(loc, memref, b));
   b.create<linalg::CopyOp>(loc, memref, alloc);
   return alloc;
 }
 
 static LogicalResult
 allocateBuffersForResults(Location loc, LinalgOp linalgOp,
                           linalg::GenericOpAdaptor &adaptor,
                           SmallVectorImpl<Value> &resultBuffers, OpBuilder &b) {
for (auto en : llvm::enumerate(linalgOp->getResultTypes())) {
     Value resultTensor = adaptor.outputs()[resultIndex];
 
     // Clone output buffers whose value is actually used.
     if (linalgOp.payloadUsesValueFromOutputOperandIndex(resultIndex)) {
       resultBuffers.push_back(cloneMemref(loc, resultTensor, b));
       continue;
     }
 
-    if (auto alloc = resultTensor.getDefiningOp<AllocOp>()) {
+    if (auto alloc = resultTensor.getDefiningOp<memref::AllocOp>()) {
       resultBuffers.push_back(resultTensor);
       continue;
     }
     // Allocate buffers for statically-shaped results.
     if (memrefType.hasStaticShape()) {
-      resultBuffers.push_back(b.create<AllocOp>(loc, memrefType));
+      resultBuffers.push_back(b.create<memref::AllocOp>(loc, memrefType));
       continue;
     }
 
-    resultBuffers.push_back(b.create<AllocOp>(
+    resultBuffers.push_back(b.create<memref::AllocOp>(
         loc, memrefType, getDynOperands(loc, resultTensor, b)));
   }
   return success();
 }
 
 /// Specialization for `linalg::GenericOp` and `linalg::IndexedGenericOp`.
 /// A pattern to convert Generic Linalg operations which work on tensors to
 /// use buffers. BufferPlacement pass should be later used to move

 class BufferizeInitTensorOp : public OpConversionPattern<InitTensorOp> {
 public:
   using OpConversionPattern<InitTensorOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(InitTensorOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     linalg::InitTensorOpAdaptor adaptor(operands, op->getAttrDictionary());
-    rewriter.replaceOpWithNewOp<AllocOp>(
+    rewriter.replaceOpWithNewOp<memref::AllocOp>(
         op, getTypeConverter()->convertType(op.getType()).cast<MemRefType>(),
         adaptor.sizes());
     return success();
   }
 };
 
 /// Generic conversion pattern that matches any LinalgOp. This avoids template
 /// instantiating one pattern for each LinalgOp.
matchAndRewrite(SubTensorOp op, ArrayRef<Value> operands,
     Value sourceMemref = adaptor.source();
     assert(sourceMemref.getType().isa<MemRefType>());
 
     MemRefType subviewMemRefType =
         getTypeConverter()->convertType(op.getType()).cast<MemRefType>();
     // op.sizes() capture exactly the dynamic alloc operands matching the
     // subviewMemRefType thanks to subview/subtensor canonicalization and
     // verification.
-    Value alloc =
-        rewriter.create<AllocOp>(op.getLoc(), subviewMemRefType, op.sizes());
+    Value alloc = rewriter.create<memref::AllocOp>(
+        op.getLoc(), subviewMemRefType, op.sizes());
     Value subView = rewriter.create<SubViewOp>(
         op.getLoc(), sourceMemref, op.getMixedOffsets(), op.getMixedSizes(),
         op.getMixedStrides());
     rewriter.create<linalg::CopyOp>(op.getLoc(), subView, alloc);
     rewriter.replaceOp(op, alloc);
     return success();
   }
 };

 struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
   void runOnOperation() override {
     MLIRContext &context = getContext();
     ConversionTarget target(context);
     BufferizeTypeConverter typeConverter;
 
     // Mark all Standard operations legal.
     target.addLegalDialect<AffineDialect, math::MathDialect,
-                           StandardOpsDialect>();
+                           memref::MemRefDialect, StandardOpsDialect>();
     target.addIllegalOp<InitTensorOp, SubTensorOp, SubTensorInsertOp>();
 
     // Mark all Linalg operations illegal as long as they work on tensors.
     auto isLegalOperation = [&](Operation *op) {
       return typeConverter.isLegal(op);
     };
     target.addDynamicallyLegalDialect<linalg::LinalgDialect>(isLegalOperation);
     target.addDynamicallyLegalOp<ConstantOp>(isLegalOperation);

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

 //===- Hoisting.cpp - Linalg hoisting transformations ---------------------===//
 //
 // 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 functions concerned with hoisting invariant operations
 // in the context of Linalg transformations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/SCF/Utils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"

 using namespace mlir;
 using namespace mlir::linalg;
 
 void mlir::linalg::hoistViewAllocOps(FuncOp func) {
   bool changed = true;
   while (changed) {
     changed = false;
     func.walk([&changed](Operation *op) {
-      if (!isa<AllocOp, AllocaOp, DeallocOp>(op))
+      if (!isa<memref::AllocOp, memref::AllocaOp, memref::DeallocOp>(op))
         return;
 
       LLVM_DEBUG(DBGS() << "Candidate for hoisting: " << *op << "\n");
       auto loop = dyn_cast<scf::ForOp>(op->getParentOp());
       LLVM_DEBUG(DBGS() << "Parent op: " << *op->getParentOp() << "\n");
 
       // Only hoist out of immediately enclosing scf::ForOp.
       if (!loop)
func.walk([&changed](Operation *op) {
 
       // If alloc has other uses than ViewLikeOp and DeallocOp don't hoist.
       Value v;
       if (op->getNumResults() > 0) {
         assert(op->getNumResults() == 1 && "Unexpected multi-result alloc");
         v = op->getResult(0);
       }
       if (v && !llvm::all_of(v.getUses(), [&](OpOperand &operand) {
-            return isa<ViewLikeOpInterface, DeallocOp>(operand.getOwner());
+            return isa<ViewLikeOpInterface, memref::DeallocOp>(
+                operand.getOwner());
           })) {
         LLVM_DEBUG(DBGS() << "Found non view-like or dealloc use: bail\n");
         return;
       }
 
       // Move AllocOp before the loop.
-      if (isa<AllocOp, AllocaOp>(op))
+      if (isa<memref::AllocOp, memref::AllocaOp>(op))
         (void)loop.moveOutOfLoop({op});
       else // Move DeallocOp outside of the loop.
         op->moveAfter(loop);
       changed = true;
     });
   }
 }
 

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

 using namespace mlir::scf;
 
 using llvm::MapVector;
 
 using folded_affine_min = FoldedValueBuilder<AffineMinOp>;
 using folded_linalg_range = FoldedValueBuilder<linalg::RangeOp>;
 using folded_std_dim = FoldedValueBuilder<DimOp>;
 using folded_std_subview = FoldedValueBuilder<SubViewOp>;
-using folded_std_view = FoldedValueBuilder<ViewOp>;
+using folded_memref_view = FoldedValueBuilder<memref::ViewOp>;
 
 #define DEBUG_TYPE "linalg-promotion"
 
 /// Alloc a new buffer of `size`. If `dynamicBuffers` is true allocate exactly
 /// the size needed, otherwise try to allocate a static bounding box.
 static Value allocBuffer(const LinalgPromotionOptions &options,
                          Type elementType, Value size, bool dynamicBuffers,
                          OperationFolder *folder,
                          Optional<unsigned> alignment = None) {
   auto *ctx = size.getContext();
   auto width = llvm::divideCeil(elementType.getIntOrFloatBitWidth(), 8);
   IntegerAttr alignment_attr;
   if (alignment.hasValue())
     alignment_attr =
         IntegerAttr::get(IntegerType::get(ctx, 64), alignment.getValue());
   if (!dynamicBuffers)
     if (auto cst = size.getDefiningOp<ConstantIndexOp>())
       return options.useAlloca
-                 ? std_alloca(MemRefType::get(width * cst.getValue(),
+                 ? memref_alloca(MemRefType::get(width * cst.getValue(),
                                                  IntegerType::get(ctx, 8)),
                                  ValueRange{}, alignment_attr)
                        .value
-                 : std_alloc(MemRefType::get(width * cst.getValue(),
+                 : memref_alloc(MemRefType::get(width * cst.getValue(),
                                                 IntegerType::get(ctx, 8)),
                                 ValueRange{}, alignment_attr)
                        .value;
   Value mul =
       folded_std_muli(folder, folded_std_constant_index(folder, width), size);
   return options.useAlloca
-             ? std_alloca(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
+             ? memref_alloca(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
                              alignment_attr)
                    .value
-             : std_alloc(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
+             : memref_alloc(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
                             alignment_attr)
                    .value;
 }
 
 /// Default allocation callback function. This allocates a promoted buffer when
 /// no call back to do so is provided. The default is to allocate a
 /// memref<..xi8> and return a view to get a memref type of shape
 /// boundingSubViewSize.
 static Optional<Value> defaultAllocBufferCallBack(
static Optional<Value> defaultAllocBufferCallBack(
 
   Value allocSize = one;
   for (auto size : llvm::enumerate(boundingSubViewSize))
     allocSize = folded_std_muli(folder, allocSize, size.value());
   Value buffer = allocBuffer(options, viewType.getElementType(), allocSize,
                              dynamicBuffers, folder, alignment);
   SmallVector<int64_t, 4> dynSizes(boundingSubViewSize.size(),
                                    ShapedType::kDynamicSize);
-  Value view = folded_std_view(
+  Value view = folded_memref_view(
       folder, MemRefType::get(dynSizes, viewType.getElementType()), buffer,
       zero, boundingSubViewSize);
   return view;
 }
 
 /// Default implementation of deallocation of the buffer use for promotion. It
 /// expects to get the same value that the default allocation method returned,
 /// i.e. result of a ViewOp.
 static LogicalResult
 defaultDeallocBufferCallBack(const LinalgPromotionOptions &options,
                              OpBuilder &b, Value fullLocalView) {
-  auto viewOp = fullLocalView.getDefiningOp<ViewOp>();
+  auto viewOp = fullLocalView.getDefiningOp<memref::ViewOp>();
   assert(viewOp && "expected full local view to be a ViewOp");
   if (!options.useAlloca)
-    std_dealloc(viewOp.source());
+    memref_dealloc(viewOp.source());
   return success();
 }
 
 namespace {
 
 /// Helper struct that captures the information required to apply the
 /// transformation on each op. This bridges the abstraction gap with the
 /// user-facing API which exposes positional arguments to control which operands

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

static Value genOutputBuffer(CodeGen &codegen, PatternRewriter &rewriter,
   // but slightly imprecise IR, so it is put under an experimental option.
   if (codegen.options.fastOutput)
     return rewriter.create<TensorToMemrefOp>(loc, denseTp, tensor);
   // By default, a new buffer is allocated which is initialized to the
   // tensor defined in the outs() clause. This is always correct but
   // introduces a dense initialization component that may negatively
   // impact the running complexity of the sparse kernel.
   Value init = rewriter.create<TensorToMemrefOp>(loc, denseTp, tensor);
-  Value alloc = rewriter.create<AllocOp>(loc, denseTp, args);
+  Value alloc = rewriter.create<memref::AllocOp>(loc, denseTp, args);
   rewriter.create<linalg::CopyOp>(loc, init, alloc);
   return alloc;
 }
 
 /// Local bufferization of all dense and sparse data structures.
 /// This code enables testing the first prototype sparse compiler.
 // TODO: replace this with a proliferated bufferization strategy
 static void genBuffers(Merger &merger, CodeGen &codegen,
for (unsigned i = 0, m = map.getNumResults(); i < m; ++i) {
     unsigned idx = map.getDimPosition(i);
     args.push_back(codegen.loops[idx]); // universal dense index
   }
   Location loc = op.getLoc();
   Value ptr = codegen.buffers[tensor];
   if (codegen.curVecLength > 1)
     genVectorStore(codegen, rewriter, rhs, ptr, args);
   else
-    rewriter.create<StoreOp>(loc, rhs, ptr, args);
+    rewriter.create<memref::StoreOp>(loc, rhs, ptr, args);
 }
 
 /// Generates a pointer/index load from the sparse storage scheme.
 static Value genLoad(CodeGen &codegen, PatternRewriter &rewriter, Location loc,
                      Value ptr, Value s) {
   if (codegen.curVecLength > 1)
     return genVectorLoad(codegen, rewriter, ptr, {s});
   Value load = rewriter.create<LoadOp>(loc, ptr, s);

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

void mlir::linalg::populateLinalgTilingCanonicalizationPatterns(
   AffineMinOp::getCanonicalizationPatterns(patterns, ctx);
   AffineMaxOp::getCanonicalizationPatterns(patterns, ctx);
   scf::ForOp::getCanonicalizationPatterns(patterns, ctx);
   scf::ParallelOp::getCanonicalizationPatterns(patterns, ctx);
   ConstantIndexOp::getCanonicalizationPatterns(patterns, ctx);
   SubTensorOp::getCanonicalizationPatterns(patterns, ctx);
   SubViewOp::getCanonicalizationPatterns(patterns, ctx);
   tensor::CastOp::getCanonicalizationPatterns(patterns, ctx);
-  ViewOp::getCanonicalizationPatterns(patterns, ctx);
+  memref::ViewOp::getCanonicalizationPatterns(patterns, ctx);
   CanonicalizationPatternList<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
       >::insert(patterns, ctx);
 }
 
 /// Populate the given list with patterns that apply Linalg tiling.
 static void insertTilingPatterns(OwningRewritePatternList &patterns,

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

static Value buildVectorWrite(OpBuilder &builder, Value value, Value dest) {
   Operation *write;
   auto shapedType = dest.getType().cast<ShapedType>();
   if (VectorType vectorType = extractVectorTypeFromShapedValue(dest)) {
     SmallVector<Value> indices(shapedType.getRank(), std_constant_index(0));
     if (vectorType != value.getType())
       value = vector_broadcast(vectorType, value);
     write = vector_transfer_write(value, dest, indices);
   } else {
-    write = std_store(value, dest);
+    write = memref_store(value, dest);
   }
   LLVM_DEBUG(dbgs() << "\n[" DEBUG_TYPE "]: vectorized op: " << *write);
   if (!write->getResults().empty())
     return write->getResult(0);
   return Value();
 }
 
 /// If value of assumed VectorType has a shape different than `shape`, buil and
LogicalResult ConvOpVectorization<ConvOp, N>::matchAndRewrite(
 
   std::vector<StringRef> iteratorTypes(numDims, "reduction");
 
   auto result = rewriter.create<vector::ContractionOp>(
       loc, inputVec, kernelVec, acc,
       rewriter.getAffineMapArrayAttr(indexingMaps),
       rewriter.getStrArrayAttr(iteratorTypes));
 
-  rewriter.create<StoreOp>(loc, result, output, ValueRange(zeros));
+  rewriter.create<memref::StoreOp>(loc, result, output, ValueRange(zeros));
   rewriter.eraseOp(op);
   return success();
 }
 
 using ConvOpConst = ConvOpVectorization<ConvWOp, 1>;
 
 /// Inserts tiling, promotion and vectorization pattern for ConvOp
 /// conversion into corresponding pattern lists.

 
 /// TODO: use interfaces, side-effects and aliasing analysis as appropriate,
 /// when available.
 LogicalResult LinalgCopyVTRForwardingPattern::matchAndRewrite(
     vector::TransferReadOp xferOp, PatternRewriter &rewriter) const {
 
   // Transfer into `view`.
   Value viewOrAlloc = xferOp.source();
-  if (!viewOrAlloc.getDefiningOp<ViewOp>() &&
-      !viewOrAlloc.getDefiningOp<AllocOp>())
+  if (!viewOrAlloc.getDefiningOp<memref::ViewOp>() &&
+      !viewOrAlloc.getDefiningOp<memref::AllocOp>())
     return failure();
 
   LLVM_DEBUG(llvm::dbgs() << "\n[" DEBUG_TYPE "]: " << viewOrAlloc);
 
   // Ensure there is exactly one subview of `viewOrAlloc` defining `subView`.
   SubViewOp subViewOp = getSubViewUseIfUnique(viewOrAlloc);
   if (!subViewOp)
     return failure();

 }
 
 /// TODO: use interfaces, side-effects and aliasing analysis as appropriate,
 /// when available.
 LogicalResult LinalgCopyVTWForwardingPattern::matchAndRewrite(
     vector::TransferWriteOp xferOp, PatternRewriter &rewriter) const {
   // Transfer into `viewOrAlloc`.
   Value viewOrAlloc = xferOp.source();
-  if (!viewOrAlloc.getDefiningOp<ViewOp>() &&
-      !viewOrAlloc.getDefiningOp<AllocOp>())
+  if (!viewOrAlloc.getDefiningOp<memref::ViewOp>() &&
+      !viewOrAlloc.getDefiningOp<memref::AllocOp>())
     return failure();
 
   // Ensure there is exactly one subview of `viewOrAlloc` defining `subView`.
   SubViewOp subViewOp = getSubViewUseIfUnique(viewOrAlloc);
   if (!subViewOp)
     return failure();
   Value subView = subViewOp.getResult();
 

mlir/lib/Dialect/MemRef/CMakeLists.txt

+add_subdirectory(IR)

mlir/lib/Dialect/MemRef/IR/CMakeLists.txt

+add_mlir_dialect_library(MLIRMemRef
+  MemRefDialect.cpp
+  MemRefOps.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRefDialect
+
+  DEPENDS
+  MLIRMemRefOpsIncGen
+
+  LINK_COMPONENTS
+  Core
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRSupport
+)

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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/MemRef/IR/MemRef.h"
+#include "mlir/Transforms/InliningUtils.h"
+
+using namespace mlir;
+using namespace mlir::memref;
+
+//===----------------------------------------------------------------------===//
+// MemRefDialect Dialect Interfaces
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct MemRefInlinerInterface : public DialectInlinerInterface {
+  using DialectInlinerInterface::DialectInlinerInterface;
+  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
+                       BlockAndValueMapping &valueMapping) const final {
+    return true;
+  }
+  bool isLegalToInline(Operation *, Region *, bool wouldBeCloned,
+                       BlockAndValueMapping &) const final {
+    return true;
+  }
+};
+} // end anonymous namespace
+
+void MemRefDialect::initialize() {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"
+      >();
+  addInterfaces<MemRefInlinerInterface>();
+}

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/AffineMap.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Matchers.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/IR/TypeUtilities.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace mlir;
+using namespace mlir::memref;
+
+/// Matches a ConstantIndexOp.
+/// TODO: This should probably just be a general matcher that uses m_Constant
+/// and checks the operation for an index type.
+static detail::op_matcher<ConstantIndexOp> m_ConstantIndex() {
+  return detail::op_matcher<ConstantIndexOp>();
+}
+
+//===----------------------------------------------------------------------===//
+// Common canonicalization pattern support logic
+//===----------------------------------------------------------------------===//
+
+/// This is a common class used for patterns of the form
+/// "someop(memrefcast) -> someop".  It folds the source of any memref.cast
+/// into the root operation directly.
+static LogicalResult foldMemRefCast(Operation *op) {
+  bool folded = false;
+  for (OpOperand &operand : op->getOpOperands()) {
+    auto cast = operand.get().getDefiningOp<CastOp>();
+    if (cast && !cast.getOperand().getType().isa<UnrankedMemRefType>()) {
+      operand.set(cast.getOperand());
+      folded = true;
+    }
+  }
+  return success(folded);
+}
+
+//===----------------------------------------------------------------------===//
+// Helpers for Tensor[Load|Store]Op, TensorToMemrefOp, and GlobalOp
+//===----------------------------------------------------------------------===//
+
+static Type getTensorTypeFromMemRefType(Type type) {
+  if (auto memref = type.dyn_cast<MemRefType>())
+    return RankedTensorType::get(memref.getShape(), memref.getElementType());
+  if (auto memref = type.dyn_cast<UnrankedMemRefType>())
+    return UnrankedTensorType::get(memref.getElementType());
+  return NoneType::get(type.getContext());
+}
+
+//===----------------------------------------------------------------------===//
+// AllocOp / AllocaOp
+//===----------------------------------------------------------------------===//
+
+template <typename AllocLikeOp>
+static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
+  static_assert(llvm::is_one_of<AllocLikeOp, AllocOp, AllocaOp>::value,
+                "applies to only alloc or alloca");
+  auto memRefType = op.getResult().getType().template dyn_cast<MemRefType>();
+  if (!memRefType)
+    return op.emitOpError("result must be a memref");
+
+  if (static_cast<int64_t>(op.dynamicSizes().size()) !=
+      memRefType.getNumDynamicDims())
+    return op.emitOpError("dimension operand count does not equal memref "
+                          "dynamic dimension count");
+
+  unsigned numSymbols = 0;
+  if (!memRefType.getAffineMaps().empty())
+    numSymbols = memRefType.getAffineMaps().front().getNumSymbols();
+  if (op.symbolOperands().size() != numSymbols)
+    return op.emitOpError(
+        "symbol operand count does not equal memref symbol count");
+
+  return success();
+}
+
+static LogicalResult verify(AllocOp op) { return verifyAllocLikeOp(op); }
+
+static LogicalResult verify(AllocaOp op) {
+  // An alloca op needs to have an ancestor with an allocation scope trait.
+  if (!op->getParentWithTrait<OpTrait::AutomaticAllocationScope>())
+    return op.emitOpError(
+        "requires an ancestor op with AutomaticAllocationScope trait");
+
+  return verifyAllocLikeOp(op);
+}
+
+namespace {
+/// Fold constant dimensions into an alloc like operation.
+template <typename AllocLikeOp>
+struct SimplifyAllocConst : public OpRewritePattern<AllocLikeOp> {
+  using OpRewritePattern<AllocLikeOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(AllocLikeOp alloc,
+                                PatternRewriter &rewriter) const override {
+    // Check to see if any dimensions operands are constants.  If so, we can
+    // substitute and drop them.
+    if (llvm::none_of(alloc.getOperands(), [](Value operand) {
+          return matchPattern(operand, m_ConstantIndex());
+        }))
+      return failure();
+
+    auto memrefType = alloc.getType();
+
+    // Ok, we have one or more constant operands.  Collect the non-constant ones
+    // and keep track of the resultant memref type to build.
+    SmallVector<int64_t, 4> newShapeConstants;
+    newShapeConstants.reserve(memrefType.getRank());
+    SmallVector<Value, 4> newOperands;
+
+    unsigned dynamicDimPos = 0;
+    for (unsigned dim = 0, e = memrefType.getRank(); dim < e; ++dim) {
+      int64_t dimSize = memrefType.getDimSize(dim);
+      // If this is already static dimension, keep it.
+      if (dimSize != -1) {
+        newShapeConstants.push_back(dimSize);
+        continue;
+      }
+      auto *defOp = alloc.getOperand(dynamicDimPos).getDefiningOp();
+      if (auto constantIndexOp = dyn_cast_or_null<ConstantIndexOp>(defOp)) {
+        // Dynamic shape dimension will be folded.
+        newShapeConstants.push_back(constantIndexOp.getValue());
+      } else {
+        // Dynamic shape dimension not folded; copy operand from old memref.
+        newShapeConstants.push_back(-1);
+        newOperands.push_back(alloc.getOperand(dynamicDimPos));
+      }
+      dynamicDimPos++;
+    }
+
+    // Create new memref type (which will have fewer dynamic dimensions).
+    MemRefType newMemRefType =
+        MemRefType::Builder(memrefType).setShape(newShapeConstants);
+    assert(static_cast<int64_t>(newOperands.size()) ==
+           newMemRefType.getNumDynamicDims());
+
+    // Create and insert the alloc op for the new memref.
+    auto newAlloc = rewriter.create<AllocLikeOp>(alloc.getLoc(), newMemRefType,
+                                                 newOperands, IntegerAttr());
+    // Insert a cast so we have the same type as the old alloc.
+    auto resultCast =
+        rewriter.create<CastOp>(alloc.getLoc(), newAlloc, alloc.getType());
+
+    rewriter.replaceOp(alloc, {resultCast});
+    return success();
+  }
+};
+
+/// Fold alloc operations with no uses. Alloc has side effects on the heap,
+/// but can still be deleted if it has zero uses.
+struct SimplifyDeadAlloc : public OpRewritePattern<AllocOp> {
+  using OpRewritePattern<AllocOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(AllocOp alloc,
+                                PatternRewriter &rewriter) const override {
+    if (alloc.use_empty()) {
+      rewriter.eraseOp(alloc);
+      return success();
+    }
+    return failure();
+  }
+};
+} // end anonymous namespace.
+
+void AllocOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                          MLIRContext *context) {
+  results.insert<SimplifyAllocConst<AllocOp>, SimplifyDeadAlloc>(context);
+}
+
+void AllocaOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                           MLIRContext *context) {
+  results.insert<SimplifyAllocConst<AllocaOp>>(context);
+}
+
+//===----------------------------------------------------------------------===//
+// CastOp
+//===----------------------------------------------------------------------===//
+
+/// Determines whether MemRef_CastOp casts to a more dynamic version of the
+/// source memref. This is useful to to fold a memref.cast into a consuming op
+/// and implement canonicalization patterns for ops in different dialects that
+/// may consume the results of memref.cast operations. Such foldable memref.cast
+/// operations are typically inserted as `view` and `subview` ops are
+/// canonicalized, to preserve the type compatibility of their uses.
+///
+/// Returns true when all conditions are met:
+/// 1. source and result are ranked memrefs with strided semantics and same
+/// element type and rank.
+/// 2. each of the source's size, offset or stride has more static information
+/// than the corresponding result's size, offset or stride.
+///
+/// Example 1:
+/// ```mlir
+///   %1 = memref.cast %0 : memref<8x16xf32> to memref<?x?xf32>
+///   %2 = consumer %1 ... : memref<?x?xf32> ...
+/// ```
+///
+/// may fold into:
+///
+/// ```mlir
+///   %2 = consumer %0 ... : memref<8x16xf32> ...
+/// ```
+///
+/// Example 2:
+/// ```
+///   %1 = memref.cast %0 : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
+///          to memref<?x?xf32>
+///   consumer %1 : memref<?x?xf32> ...
+/// ```
+///
+/// may fold into:
+///
+/// ```
+///   consumer %0 ... : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
+/// ```
+bool CastOp::canFoldIntoConsumerOp(CastOp castOp) {
+  MemRefType sourceType = castOp.source().getType().dyn_cast<MemRefType>();
+  MemRefType resultType = castOp.getType().dyn_cast<MemRefType>();
+
+  // Requires ranked MemRefType.
+  if (!sourceType || !resultType)
+    return false;
+
+  // Requires same elemental type.
+  if (sourceType.getElementType() != resultType.getElementType())
+    return false;
+
+  // Requires same rank.
+  if (sourceType.getRank() != resultType.getRank())
+    return false;
+
+  // Only fold casts between strided memref forms.
+  int64_t sourceOffset, resultOffset;
+  SmallVector<int64_t, 4> sourceStrides, resultStrides;
+  if (failed(getStridesAndOffset(sourceType, sourceStrides, sourceOffset)) ||
+      failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
+    return false;
+
+  // If cast is towards more static sizes along any dimension, don't fold.
+  for (auto it : llvm::zip(sourceType.getShape(), resultType.getShape())) {
+    auto ss = std::get<0>(it), st = std::get<1>(it);
+    if (ss != st)
+      if (MemRefType::isDynamic(ss) && !MemRefType::isDynamic(st))
+        return false;
+  }
+
+  // If cast is towards more static offset along any dimension, don't fold.
+  if (sourceOffset != resultOffset)
+    if (MemRefType::isDynamicStrideOrOffset(sourceOffset) &&
+        !MemRefType::isDynamicStrideOrOffset(resultOffset))
+      return false;
+
+  // If cast is towards more static strides along any dimension, don't fold.
+  for (auto it : llvm::zip(sourceStrides, resultStrides)) {
+    auto ss = std::get<0>(it), st = std::get<1>(it);
+    if (ss != st)
+      if (MemRefType::isDynamicStrideOrOffset(ss) &&
+          !MemRefType::isDynamicStrideOrOffset(st))
+        return false;
+  }
+
+  return true;
+}
+
+bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
+  if (inputs.size() != 1 || outputs.size() != 1)
+    return false;
+  Type a = inputs.front(), b = outputs.front();
+  auto aT = a.dyn_cast<MemRefType>();
+  auto bT = b.dyn_cast<MemRefType>();
+
+  auto uaT = a.dyn_cast<UnrankedMemRefType>();
+  auto ubT = b.dyn_cast<UnrankedMemRefType>();
+
+  if (aT && bT) {
+    if (aT.getElementType() != bT.getElementType())
+      return false;
+    if (aT.getAffineMaps() != bT.getAffineMaps()) {
+      int64_t aOffset, bOffset;
+      SmallVector<int64_t, 4> aStrides, bStrides;
+      if (failed(getStridesAndOffset(aT, aStrides, aOffset)) ||
+          failed(getStridesAndOffset(bT, bStrides, bOffset)) ||
+          aStrides.size() != bStrides.size())
+        return false;
+
+      // Strides along a dimension/offset are compatible if the value in the
+      // source memref is static and the value in the target memref is the
+      // same. They are also compatible if either one is dynamic (see
+      // description of MemRefCastOp for details).
+      auto checkCompatible = [](int64_t a, int64_t b) {
+        return (a == MemRefType::getDynamicStrideOrOffset() ||
+                b == MemRefType::getDynamicStrideOrOffset() || a == b);
+      };
+      if (!checkCompatible(aOffset, bOffset))
+        return false;
+      for (auto aStride : enumerate(aStrides))
+        if (!checkCompatible(aStride.value(), bStrides[aStride.index()]))
+          return false;
+    }
+    if (aT.getMemorySpace() != bT.getMemorySpace())
+      return false;
+
+    // They must have the same rank, and any specified dimensions must match.
+    if (aT.getRank() != bT.getRank())
+      return false;
+
+    for (unsigned i = 0, e = aT.getRank(); i != e; ++i) {
+      int64_t aDim = aT.getDimSize(i), bDim = bT.getDimSize(i);
+      if (aDim != -1 && bDim != -1 && aDim != bDim)
+        return false;
+    }
+    return true;
+  } else {
+    if (!aT && !uaT)
+      return false;
+    if (!bT && !ubT)
+      return false;
+    // Unranked to unranked casting is unsupported
+    if (uaT && ubT)
+      return false;
+
+    auto aEltType = (aT) ? aT.getElementType() : uaT.getElementType();
+    auto bEltType = (bT) ? bT.getElementType() : ubT.getElementType();
+    if (aEltType != bEltType)
+      return false;
+
+    auto aMemSpace = (aT) ? aT.getMemorySpace() : uaT.getMemorySpace();
+    auto bMemSpace = (bT) ? bT.getMemorySpace() : ubT.getMemorySpace();
+    if (aMemSpace != bMemSpace)
+      return false;
+
+    return true;
+  }
+
+  return false;
+}
+
+OpFoldResult CastOp::fold(ArrayRef<Attribute> operands) {
+  return succeeded(foldMemRefCast(*this)) ? getResult() : Value();
+}
+
+//===----------------------------------------------------------------------===//
+// DeallocOp
+//===----------------------------------------------------------------------===//
+namespace {
+/// Fold Dealloc operations that are deallocating an AllocOp that is only used
+/// by other Dealloc operations.
+struct SimplifyDeadDealloc : public OpRewritePattern<DeallocOp> {
+  using OpRewritePattern<DeallocOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(DeallocOp dealloc,
+                                PatternRewriter &rewriter) const override {
+    // Check that the memref operand's defining operation is an AllocOp.
+    Value memref = dealloc.memref();
+    if (!isa_and_nonnull<AllocOp>(memref.getDefiningOp()))
+      return failure();
+
+    // Check that all of the uses of the AllocOp are other DeallocOps.
+    for (auto *user : memref.getUsers())
+      if (!isa<DeallocOp>(user))
+        return failure();
+
+    // Erase the dealloc operation.
+    rewriter.eraseOp(dealloc);
+    return success();
+  }
+};
+} // end anonymous namespace.
+
+static LogicalResult verify(DeallocOp op) {
+  if (!op.memref().getType().isa<MemRefType>())
+    return op.emitOpError("operand must be a memref");
+  return success();
+}
+
+void DeallocOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                            MLIRContext *context) {
+  results.insert<SimplifyDeadDealloc>(context);
+}
+
+LogicalResult DeallocOp::fold(ArrayRef<Attribute> cstOperands,
+                              SmallVectorImpl<OpFoldResult> &results) {
+  /// dealloc(memrefcast) -> dealloc
+  return foldMemRefCast(*this);
+}
+
+//===----------------------------------------------------------------------===//
+// GlobalOp
+//===----------------------------------------------------------------------===//
+
+static void printGlobalMemrefOpTypeAndInitialValue(OpAsmPrinter &p, GlobalOp op,
+                                                   TypeAttr type,
+                                                   Attribute initialValue) {
+  p << type;
+  if (!op.isExternal()) {
+    p << " = ";
+    if (op.isUninitialized())
+      p << "uninitialized";
+    else
+      p.printAttributeWithoutType(initialValue);
+  }
+}
+
+static ParseResult
+parseGlobalMemrefOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr,
+                                       Attribute &initialValue) {
+  Type type;
+  if (parser.parseType(type))
+    return failure();
+
+  auto memrefType = type.dyn_cast<MemRefType>();
+  if (!memrefType || !memrefType.hasStaticShape())
+    return parser.emitError(parser.getNameLoc())
+           << "type should be static shaped memref, but got " << type;
+  typeAttr = TypeAttr::get(type);
+
+  if (parser.parseOptionalEqual())
+    return success();
+
+  if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
+    initialValue = UnitAttr::get(parser.getBuilder().getContext());
+    return success();
+  }
+
+  Type tensorType = getTensorTypeFromMemRefType(memrefType);
+  if (parser.parseAttribute(initialValue, tensorType))
+    return failure();
+  if (!initialValue.isa<ElementsAttr>())
+    return parser.emitError(parser.getNameLoc())
+           << "initial value should be a unit or elements attribute";
+  return success();
+}
+
+static LogicalResult verify(GlobalOp op) {
+  auto memrefType = op.type().dyn_cast<MemRefType>();
+  if (!memrefType || !memrefType.hasStaticShape())
+    return op.emitOpError("type should be static shaped memref, but got ")
+           << op.type();
+
+  // Verify that the initial value, if present, is either a unit attribute or
+  // an elements attribute.
+  if (op.initial_value().hasValue()) {
+    Attribute initValue = op.initial_value().getValue();
+    if (!initValue.isa<UnitAttr>() && !initValue.isa<ElementsAttr>())
+      return op.emitOpError("initial value should be a unit or elements "
+                            "attribute, but got ")
+             << initValue;
+
+    // Check that the type of the initial value is compatible with the type of
+    // the global variable.
+    if (initValue.isa<ElementsAttr>()) {
+      Type initType = initValue.getType();
+      Type tensorType = getTensorTypeFromMemRefType(memrefType);
+      if (initType != tensorType)
+        return op.emitOpError("initial value expected to be of type ")
+               << tensorType << ", but was of type " << initType;
+    }
+  }
+
+  // TODO: verify visibility for declarations.
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// GetGlobalOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult
+GetGlobalOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
+  // Verify that the result type is same as the type of the referenced
+  // memref.global op.
+  auto global =
+      symbolTable.lookupNearestSymbolFrom<GlobalOp>(*this, nameAttr());
+  if (!global)
+    return emitOpError("'")
+           << name() << "' does not reference a valid global memref";
+
+  Type resultType = result().getType();
+  if (global.type() != resultType)
+    return emitOpError("result type ")
+           << resultType << " does not match type " << global.type()
+           << " of the global memref @" << name();
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// PrefetchOp
+//===----------------------------------------------------------------------===//
+
+static void print(OpAsmPrinter &p, PrefetchOp op) {
+  p << PrefetchOp::getOperationName() << " " << op.memref() << '[';
+  p.printOperands(op.indices());
+  p << ']' << ", " << (op.isWrite() ? "write" : "read");
+  p << ", locality<" << op.localityHint();
+  p << ">, " << (op.isDataCache() ? "data" : "instr");
+  p.printOptionalAttrDict(
+      op.getAttrs(),
+      /*elidedAttrs=*/{"localityHint", "isWrite", "isDataCache"});
+  p << " : " << op.getMemRefType();
+}
+
+static ParseResult parsePrefetchOp(OpAsmParser &parser,
+                                   OperationState &result) {
+  OpAsmParser::OperandType memrefInfo;
+  SmallVector<OpAsmParser::OperandType, 4> indexInfo;
+  IntegerAttr localityHint;
+  MemRefType type;
+  StringRef readOrWrite, cacheType;
+
+  auto indexTy = parser.getBuilder().getIndexType();
+  auto i32Type = parser.getBuilder().getIntegerType(32);
+  if (parser.parseOperand(memrefInfo) ||
+      parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square) ||
+      parser.parseComma() || parser.parseKeyword(&readOrWrite) ||
+      parser.parseComma() || parser.parseKeyword("locality") ||
+      parser.parseLess() ||
+      parser.parseAttribute(localityHint, i32Type, "localityHint",
+                            result.attributes) ||
+      parser.parseGreater() || parser.parseComma() ||
+      parser.parseKeyword(&cacheType) || parser.parseColonType(type) ||
+      parser.resolveOperand(memrefInfo, type, result.operands) ||
+      parser.resolveOperands(indexInfo, indexTy, result.operands))
+    return failure();
+
+  if (!readOrWrite.equals("read") && !readOrWrite.equals("write"))
+    return parser.emitError(parser.getNameLoc(),
+                            "rw specifier has to be 'read' or 'write'");
+  result.addAttribute(
+      PrefetchOp::getIsWriteAttrName(),
+      parser.getBuilder().getBoolAttr(readOrWrite.equals("write")));
+
+  if (!cacheType.equals("data") && !cacheType.equals("instr"))
+    return parser.emitError(parser.getNameLoc(),
+                            "cache type has to be 'data' or 'instr'");
+
+  result.addAttribute(
+      PrefetchOp::getIsDataCacheAttrName(),
+      parser.getBuilder().getBoolAttr(cacheType.equals("data")));
+
+  return success();
+}
+
+static LogicalResult verify(PrefetchOp op) {
+  if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
+    return op.emitOpError("too few indices");
+
+  return success();
+}
+
+LogicalResult PrefetchOp::fold(ArrayRef<Attribute> cstOperands,
+                               SmallVectorImpl<OpFoldResult> &results) {
+  // prefetch(memrefcast) -> prefetch
+  return foldMemRefCast(*this);
+}
+
+//===----------------------------------------------------------------------===//
+// ReshapeOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(ReshapeOp op) {
+  Type operandType = op.source().getType();
+  Type resultType = op.result().getType();
+
+  Type operandElementType = operandType.cast<ShapedType>().getElementType();
+  Type resultElementType = resultType.cast<ShapedType>().getElementType();
+  if (operandElementType != resultElementType)
+    return op.emitOpError("element types of source and destination memref "
+                          "types should be the same");
+
+  if (auto operandMemRefType = operandType.dyn_cast<MemRefType>())
+    if (!operandMemRefType.getAffineMaps().empty())
+      return op.emitOpError(
+          "source memref type should have identity affine map");
+
+  int64_t shapeSize = op.shape().getType().cast<MemRefType>().getDimSize(0);
+  auto resultMemRefType = resultType.dyn_cast<MemRefType>();
+  if (resultMemRefType) {
+    if (!resultMemRefType.getAffineMaps().empty())
+      return op.emitOpError(
+          "result memref type should have identity affine map");
+    if (shapeSize == ShapedType::kDynamicSize)
+      return op.emitOpError("cannot use shape operand with dynamic length to "
+                            "reshape to statically-ranked memref type");
+    if (shapeSize != resultMemRefType.getRank())
+      return op.emitOpError(
+          "length of shape operand differs from the result's memref rank");
+  }
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// StoreOp
+//===----------------------------------------------------------------------===//
+
+static LogicalResult verify(StoreOp op) {
+  if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
+    return op.emitOpError("store index operand count not equal to memref rank");
+
+  return success();
+}
+
+LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
+                            SmallVectorImpl<OpFoldResult> &results) {
+  /// store(memrefcast) -> store
+  return foldMemRefCast(*this);
+}
+
+//===----------------------------------------------------------------------===//
+// TransposeOp
+//===----------------------------------------------------------------------===//
+
+/// Build a strided memref type by applying `permutationMap` tp `memRefType`.
+static MemRefType inferTransposeResultType(MemRefType memRefType,
+                                           AffineMap permutationMap) {
+  auto rank = memRefType.getRank();
+  auto originalSizes = memRefType.getShape();
+  // Compute permuted sizes.
+  SmallVector<int64_t, 4> sizes(rank, 0);
+  for (auto en : llvm::enumerate(permutationMap.getResults()))
+    sizes[en.index()] =
+        originalSizes[en.value().cast<AffineDimExpr>().getPosition()];
+
+  // Compute permuted strides.
+  int64_t offset;
+  SmallVector<int64_t, 4> strides;
+  auto res = getStridesAndOffset(memRefType, strides, offset);
+  assert(succeeded(res) && strides.size() == static_cast<unsigned>(rank));
+  (void)res;
+  auto map =
+      makeStridedLinearLayoutMap(strides, offset, memRefType.getContext());
+  map = permutationMap ? map.compose(permutationMap) : map;
+  return MemRefType::Builder(memRefType).setShape(sizes).setAffineMaps(map);
+}
+
+void TransposeOp::build(OpBuilder &b, OperationState &result, Value in,
+                        AffineMapAttr permutation,
+                        ArrayRef<NamedAttribute> attrs) {
+  auto permutationMap = permutation.getValue();
+  assert(permutationMap);
+
+  auto memRefType = in.getType().cast<MemRefType>();
+  // Compute result type.
+  MemRefType resultType = inferTransposeResultType(memRefType, permutationMap);
+
+  build(b, result, resultType, in, attrs);
+  result.addAttribute(TransposeOp::getPermutationAttrName(), permutation);
+}
+
+// transpose $in $permutation attr-dict : type($in) `to` type(results)
+static void print(OpAsmPrinter &p, TransposeOp op) {
+  p << "transpose " << op.in() << " " << op.permutation();
+  p.printOptionalAttrDict(op.getAttrs(),
+                          {TransposeOp::getPermutationAttrName()});
+  p << " : " << op.in().getType() << " to " << op.getType();
+}
+
+static ParseResult parseTransposeOp(OpAsmParser &parser,
+                                    OperationState &result) {
+  OpAsmParser::OperandType in;
+  AffineMap permutation;
+  MemRefType srcType, dstType;
+  if (parser.parseOperand(in) || parser.parseAffineMap(permutation) ||
+      parser.parseOptionalAttrDict(result.attributes) ||
+      parser.parseColonType(srcType) ||
+      parser.resolveOperand(in, srcType, result.operands) ||
+      parser.parseKeywordType("to", dstType) ||
+      parser.addTypeToList(dstType, result.types))
+    return failure();
+
+  result.addAttribute(TransposeOp::getPermutationAttrName(),
+                      AffineMapAttr::get(permutation));
+  return success();
+}
+
+static LogicalResult verify(TransposeOp op) {
+  if (!op.permutation().isPermutation())
+    return op.emitOpError("expected a permutation map");
+  if (op.permutation().getNumDims() != op.getShapedType().getRank())
+    return op.emitOpError(
+        "expected a permutation map of same rank as the input");
+
+  auto srcType = op.in().getType().cast<MemRefType>();
+  auto dstType = op.getType().cast<MemRefType>();
+  auto transposedType = inferTransposeResultType(srcType, op.permutation());
+  if (dstType != transposedType)
+    return op.emitOpError("output type ")
+           << dstType << " does not match transposed input type " << srcType
+           << ", " << transposedType;
+  return success();
+}
+
+OpFoldResult TransposeOp::fold(ArrayRef<Attribute>) {
+  if (succeeded(foldMemRefCast(*this)))
+    return getResult();
+  return {};
+}
+
+//===----------------------------------------------------------------------===//
+// ViewOp
+//===----------------------------------------------------------------------===//
+
+static ParseResult parseViewOp(OpAsmParser &parser, OperationState &result) {
+  OpAsmParser::OperandType srcInfo;
+  SmallVector<OpAsmParser::OperandType, 1> offsetInfo;
+  SmallVector<OpAsmParser::OperandType, 4> sizesInfo;
+  auto indexType = parser.getBuilder().getIndexType();
+  Type srcType, dstType;
+  llvm::SMLoc offsetLoc;
+  if (parser.parseOperand(srcInfo) || parser.getCurrentLocation(&offsetLoc) ||
+      parser.parseOperandList(offsetInfo, OpAsmParser::Delimiter::Square))
+    return failure();
+
+  if (offsetInfo.size() != 1)
+    return parser.emitError(offsetLoc) << "expects 1 offset operand";
+
+  return failure(
+      parser.parseOperandList(sizesInfo, OpAsmParser::Delimiter::Square) ||
+      parser.parseOptionalAttrDict(result.attributes) ||
+      parser.parseColonType(srcType) ||
+      parser.resolveOperand(srcInfo, srcType, result.operands) ||
+      parser.resolveOperands(offsetInfo, indexType, result.operands) ||
+      parser.resolveOperands(sizesInfo, indexType, result.operands) ||
+      parser.parseKeywordType("to", dstType) ||
+      parser.addTypeToList(dstType, result.types));
+}
+
+static void print(OpAsmPrinter &p, ViewOp op) {
+  p << op.getOperationName() << ' ' << op.getOperand(0) << '[';
+  p.printOperand(op.byte_shift());
+  p << "][" << op.sizes() << ']';
+  p.printOptionalAttrDict(op.getAttrs());
+  p << " : " << op.getOperand(0).getType() << " to " << op.getType();
+}
+
+static LogicalResult verify(ViewOp op) {
+  auto baseType = op.getOperand(0).getType().cast<MemRefType>();
+  auto viewType = op.getType();
+
+  // The base memref should have identity layout map (or none).
+  if (baseType.getAffineMaps().size() > 1 ||
+      (baseType.getAffineMaps().size() == 1 &&
+       !baseType.getAffineMaps()[0].isIdentity()))
+    return op.emitError("unsupported map for base memref type ") << baseType;
+
+  // The result memref should have identity layout map (or none).
+  if (viewType.getAffineMaps().size() > 1 ||
+      (viewType.getAffineMaps().size() == 1 &&
+       !viewType.getAffineMaps()[0].isIdentity()))
+    return op.emitError("unsupported map for result memref type ") << viewType;
+
+  // The base memref and the view memref should be in the same memory space.
+  if (baseType.getMemorySpace() != viewType.getMemorySpace())
+    return op.emitError("different memory spaces specified for base memref "
+                        "type ")
+           << baseType << " and view memref type " << viewType;
+
+  // Verify that we have the correct number of sizes for the result type.
+  unsigned numDynamicDims = viewType.getNumDynamicDims();
+  if (op.sizes().size() != numDynamicDims)
+    return op.emitError("incorrect number of size operands for type ")
+           << viewType;
+
+  return success();
+}
+
+Value ViewOp::getViewSource() { return source(); }
+
+namespace {
+
+struct ViewOpShapeFolder : public OpRewritePattern<ViewOp> {
+  using OpRewritePattern<ViewOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(ViewOp viewOp,
+                                PatternRewriter &rewriter) const override {
+    // Return if none of the operands are constants.
+    if (llvm::none_of(viewOp.getOperands(), [](Value operand) {
+          return matchPattern(operand, m_ConstantIndex());
+        }))
+      return failure();
+
+    // Get result memref type.
+    auto memrefType = viewOp.getType();
+
+    // Get offset from old memref view type 'memRefType'.
+    int64_t oldOffset;
+    SmallVector<int64_t, 4> oldStrides;
+    if (failed(getStridesAndOffset(memrefType, oldStrides, oldOffset)))
+      return failure();
+    assert(oldOffset == 0 && "Expected 0 offset");
+
+    SmallVector<Value, 4> newOperands;
+
+    // Offset cannot be folded into result type.
+
+    // Fold any dynamic dim operands which are produced by a constant.
+    SmallVector<int64_t, 4> newShapeConstants;
+    newShapeConstants.reserve(memrefType.getRank());
+
+    unsigned dynamicDimPos = 0;
+    unsigned rank = memrefType.getRank();
+    for (unsigned dim = 0, e = rank; dim < e; ++dim) {
+      int64_t dimSize = memrefType.getDimSize(dim);
+      // If this is already static dimension, keep it.
+      if (!ShapedType::isDynamic(dimSize)) {
+        newShapeConstants.push_back(dimSize);
+        continue;
+      }
+      auto *defOp = viewOp.sizes()[dynamicDimPos].getDefiningOp();
+      if (auto constantIndexOp = dyn_cast_or_null<ConstantIndexOp>(defOp)) {
+        // Dynamic shape dimension will be folded.
+        newShapeConstants.push_back(constantIndexOp.getValue());
+      } else {
+        // Dynamic shape dimension not folded; copy operand from old memref.
+        newShapeConstants.push_back(dimSize);
+        newOperands.push_back(viewOp.sizes()[dynamicDimPos]);
+      }
+      dynamicDimPos++;
+    }
+
+    // Create new memref type with constant folded dims.
+    MemRefType newMemRefType =
+        MemRefType::Builder(memrefType).setShape(newShapeConstants);
+    // Nothing new, don't fold.
+    if (newMemRefType == memrefType)
+      return failure();
+
+    // Create new ViewOp.
+    auto newViewOp = rewriter.create<ViewOp>(viewOp.getLoc(), newMemRefType,
+                                             viewOp.getOperand(0),
+                                             viewOp.byte_shift(), newOperands);
+    // Insert a cast so we have the same type as the old memref type.
+    rewriter.replaceOpWithNewOp<CastOp>(viewOp, newViewOp, viewOp.getType());
+    return success();
+  }
+};
+
+struct ViewOpMemrefCastFolder : public OpRewritePattern<ViewOp> {
+  using OpRewritePattern<ViewOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(ViewOp viewOp,
+                                PatternRewriter &rewriter) const override {
+    Value memrefOperand = viewOp.getOperand(0);
+    CastOp memrefCastOp = memrefOperand.getDefiningOp<CastOp>();
+    if (!memrefCastOp)
+      return failure();
+    Value allocOperand = memrefCastOp.getOperand();
+    AllocOp allocOp = allocOperand.getDefiningOp<AllocOp>();
+    if (!allocOp)
+      return failure();
+    rewriter.replaceOpWithNewOp<ViewOp>(viewOp, viewOp.getType(), allocOperand,
+                                        viewOp.byte_shift(), viewOp.sizes());
+    return success();
+  }
+};
+
+} // end anonymous namespace
+
+void ViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                         MLIRContext *context) {
+  results.insert<ViewOpShapeFolder, ViewOpMemrefCastFolder>(context);
+}
+
+//===----------------------------------------------------------------------===//
+// TableGen'd op method definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"

mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp

 //===- ParallelLoopFusion.cpp - Code to perform loop 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 loop fusion on parallel loops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/Passes.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/SCF/Transforms.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpDefinition.h"
 

 
 /// Checks if the parallel loops have mixed access to the same buffers. Returns
 /// `true` if the first parallel loop writes to the same indices that the second
 /// loop reads.
 static bool haveNoReadsAfterWriteExceptSameIndex(
     ParallelOp firstPloop, ParallelOp secondPloop,
     const BlockAndValueMapping &firstToSecondPloopIndices) {
   DenseMap<Value, SmallVector<ValueRange, 1>> bufferStores;
-  firstPloop.getBody()->walk([&](StoreOp store) {
+  firstPloop.getBody()->walk([&](memref::StoreOp store) {
     bufferStores[store.getMemRef()].push_back(store.indices());
   });
   auto walkResult = secondPloop.getBody()->walk([&](LoadOp load) {
     // Stop if the memref is defined in secondPloop body. Careful alias analysis
     // is needed.
     auto *memrefDef = load.getMemRef().getDefiningOp();
     if (memrefDef && memrefDef->getBlock() == load->getBlock())
       return WalkResult::interrupt();

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 //===- Ops.cpp - Standard MLIR Operations ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 #include "mlir/Dialect/CommonFolders.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"

 static void printStandardCastOp(Operation *op, OpAsmPrinter &p) {
   int stdDotLen = StandardOpsDialect::getDialectNamespace().size() + 1;
   p << op->getName().getStringRef().drop_front(stdDotLen) << ' '
     << op->getOperand(0) << " : " << op->getOperand(0).getType() << " to "
     << op->getResult(0).getType();
 }
 
 void StandardOpsDialect::initialize() {
+  getContext()->loadDialect<memref::MemRefDialect>();
   getContext()->loadDialect<tensor::TensorDialect>();
   addOperations<DmaStartOp, DmaWaitOp,
 #define GET_OP_LIST
 #include "mlir/Dialect/StandardOps/IR/Ops.cpp.inc"
                 >();
   addInterfaces<StdInlinerInterface>();
 }
 
static detail::op_matcher<ConstantIndexOp> m_ConstantIndex() {
   return detail::op_matcher<ConstantIndexOp>();
 }
 
 //===----------------------------------------------------------------------===//
 // Common canonicalization pattern support logic
 //===----------------------------------------------------------------------===//
 
 /// This is a common class used for patterns of the form
-/// "someop(memrefcast) -> someop".  It folds the source of any memref_cast
+/// "someop(memrefcast) -> someop".  It folds the source of any memref.cast
 /// into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {
   bool folded = false;
   for (OpOperand &operand : op->getOpOperands()) {
-    auto cast = operand.get().getDefiningOp<MemRefCastOp>();
+    auto cast = operand.get().getDefiningOp<memref::CastOp>();
     if (cast && !cast.getOperand().getType().isa<UnrankedMemRefType>()) {
       operand.set(cast.getOperand());
       folded = true;
     }
   }
   return success(folded);
 }
 

 static SmallVector<int64_t, 4> extractFromI64ArrayAttr(Attribute attr) {
   return llvm::to_vector<4>(
       llvm::map_range(attr.cast<ArrayAttr>(), [](Attribute a) -> int64_t {
         return a.cast<IntegerAttr>().getInt();
       }));
 }
 
 //===----------------------------------------------------------------------===//
-// AllocOp / AllocaOp
-//===----------------------------------------------------------------------===//
-
-template <typename AllocLikeOp>
-static LogicalResult verifyAllocLikeOp(AllocLikeOp op) {
-  static_assert(llvm::is_one_of<AllocLikeOp, AllocOp, AllocaOp>::value,
-                "applies to only alloc or alloca");
-  auto memRefType = op.getResult().getType().template dyn_cast<MemRefType>();
-  if (!memRefType)
-    return op.emitOpError("result must be a memref");
-
-  if (static_cast<int64_t>(op.dynamicSizes().size()) !=
-      memRefType.getNumDynamicDims())
-    return op.emitOpError("dimension operand count does not equal memref "
-                          "dynamic dimension count");
-
-  unsigned numSymbols = 0;
-  if (!memRefType.getAffineMaps().empty())
-    numSymbols = memRefType.getAffineMaps().front().getNumSymbols();
-  if (op.symbolOperands().size() != numSymbols)
-    return op.emitOpError(
-        "symbol operand count does not equal memref symbol count");
-
-  return success();
-}
-
-static LogicalResult verify(AllocOp op) { return verifyAllocLikeOp(op); }
-
-static LogicalResult verify(AllocaOp op) {
-  // An alloca op needs to have an ancestor with an allocation scope trait.
-  if (!op->getParentWithTrait<OpTrait::AutomaticAllocationScope>())
-    return op.emitOpError(
-        "requires an ancestor op with AutomaticAllocationScope trait");
-
-  return verifyAllocLikeOp(op);
-}
-
-namespace {
-/// Fold constant dimensions into an alloc like operation.
-template <typename AllocLikeOp>
-struct SimplifyAllocConst : public OpRewritePattern<AllocLikeOp> {
-  using OpRewritePattern<AllocLikeOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(AllocLikeOp alloc,
-                                PatternRewriter &rewriter) const override {
-    // Check to see if any dimensions operands are constants.  If so, we can
-    // substitute and drop them.
-    if (llvm::none_of(alloc.getOperands(), [](Value operand) {
-          return matchPattern(operand, m_ConstantIndex());
-        }))
-      return failure();
-
-    auto memrefType = alloc.getType();
-
-    // Ok, we have one or more constant operands.  Collect the non-constant ones
-    // and keep track of the resultant memref type to build.
-    SmallVector<int64_t, 4> newShapeConstants;
-    newShapeConstants.reserve(memrefType.getRank());
-    SmallVector<Value, 4> newOperands;
-
-    unsigned dynamicDimPos = 0;
-    for (unsigned dim = 0, e = memrefType.getRank(); dim < e; ++dim) {
-      int64_t dimSize = memrefType.getDimSize(dim);
-      // If this is already static dimension, keep it.
-      if (dimSize != -1) {
-        newShapeConstants.push_back(dimSize);
-        continue;
-      }
-      auto *defOp = alloc.getOperand(dynamicDimPos).getDefiningOp();
-      if (auto constantIndexOp = dyn_cast_or_null<ConstantIndexOp>(defOp)) {
-        // Dynamic shape dimension will be folded.
-        newShapeConstants.push_back(constantIndexOp.getValue());
-      } else {
-        // Dynamic shape dimension not folded; copy operand from old memref.
-        newShapeConstants.push_back(-1);
-        newOperands.push_back(alloc.getOperand(dynamicDimPos));
-      }
-      dynamicDimPos++;
-    }
-
-    // Create new memref type (which will have fewer dynamic dimensions).
-    MemRefType newMemRefType =
-        MemRefType::Builder(memrefType).setShape(newShapeConstants);
-    assert(static_cast<int64_t>(newOperands.size()) ==
-           newMemRefType.getNumDynamicDims());
-
-    // Create and insert the alloc op for the new memref.
-    auto newAlloc = rewriter.create<AllocLikeOp>(alloc.getLoc(), newMemRefType,
-                                                 newOperands, IntegerAttr());
-    // Insert a cast so we have the same type as the old alloc.
-    auto resultCast = rewriter.create<MemRefCastOp>(alloc.getLoc(), newAlloc,
-                                                    alloc.getType());
-
-    rewriter.replaceOp(alloc, {resultCast});
-    return success();
-  }
-};
-
-/// Fold alloc operations with no uses. Alloc has side effects on the heap,
-/// but can still be deleted if it has zero uses.
-struct SimplifyDeadAlloc : public OpRewritePattern<AllocOp> {
-  using OpRewritePattern<AllocOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(AllocOp alloc,
-                                PatternRewriter &rewriter) const override {
-    if (alloc.use_empty()) {
-      rewriter.eraseOp(alloc);
-      return success();
-    }
-    return failure();
-  }
-};
-} // end anonymous namespace.
-
-void AllocOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
-                                          MLIRContext *context) {
-  results.insert<SimplifyAllocConst<AllocOp>, SimplifyDeadAlloc>(context);
-}
-
-void AllocaOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
-                                           MLIRContext *context) {
-  results.insert<SimplifyAllocConst<AllocaOp>>(context);
-}
-
-//===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult AndOp::fold(ArrayRef<Attribute> operands) {
   /// and(x, 0) -> 0
   if (matchPattern(rhs(), m_Zero()))
     return rhs();
   /// and(x, allOnes) -> x

 
 void ConstantIndexOp::build(OpBuilder &builder, OperationState &result,
                             int64_t value) {
   Type type = builder.getIndexType();
   ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
 }
 
 //===----------------------------------------------------------------------===//
-// DeallocOp
-//===----------------------------------------------------------------------===//
-namespace {
-/// Fold Dealloc operations that are deallocating an AllocOp that is only used
-/// by other Dealloc operations.
-struct SimplifyDeadDealloc : public OpRewritePattern<DeallocOp> {
-  using OpRewritePattern<DeallocOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(DeallocOp dealloc,
-                                PatternRewriter &rewriter) const override {
-    // Check that the memref operand's defining operation is an AllocOp.
-    Value memref = dealloc.memref();
-    if (!isa_and_nonnull<AllocOp>(memref.getDefiningOp()))
-      return failure();
-
-    // Check that all of the uses of the AllocOp are other DeallocOps.
-    for (auto *user : memref.getUsers())
-      if (!isa<DeallocOp>(user))
-        return failure();
-
-    // Erase the dealloc operation.
-    rewriter.eraseOp(dealloc);
-    return success();
-  }
-};
-} // end anonymous namespace.
-
-static LogicalResult verify(DeallocOp op) {
-  if (!op.memref().getType().isa<MemRefType>())
-    return op.emitOpError("operand must be a memref");
-  return success();
-}
-
-void DeallocOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
-                                            MLIRContext *context) {
-  results.insert<SimplifyDeadDealloc>(context);
-}
-
-LogicalResult DeallocOp::fold(ArrayRef<Attribute> cstOperands,
-                              SmallVectorImpl<OpFoldResult> &results) {
-  /// dealloc(memrefcast) -> dealloc
-  return foldMemRefCast(*this);
-}
-
-//===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
 void DimOp::build(OpBuilder &builder, OperationState &result,
                   Value memrefOrTensor, int64_t index) {
   auto loc = result.location;
   Value indexValue = builder.create<ConstantIndexOp>(loc, index);
   build(builder, result, memrefOrTensor, indexValue);
if (auto subtensor = dyn_cast_or_null<SubTensorOp>(definingOp)) {
     return subtensor.getDynamicSize(unsignedIndex);
   }
 
   // Fold dim to the size argument for an `AllocOp`, `ViewOp`, or `SubViewOp`.
   auto memrefType = argTy.dyn_cast<MemRefType>();
   if (!memrefType)
     return {};
 
-  if (auto alloc = dyn_cast_or_null<AllocOp>(definingOp))
+  if (auto alloc = dyn_cast_or_null<memref::AllocOp>(definingOp))
     return *(alloc.getDynamicSizes().begin() +
              memrefType.getDynamicDimIndex(unsignedIndex));
 
-  if (auto view = dyn_cast_or_null<ViewOp>(definingOp))
+  if (auto view = dyn_cast_or_null<memref::ViewOp>(definingOp))
     return *(view.getDynamicSizes().begin() +
              memrefType.getDynamicDimIndex(unsignedIndex));
 
   if (auto subview = dyn_cast_or_null<SubViewOp>(definingOp)) {
     assert(subview.isDynamicSize(unsignedIndex) &&
            "Expected dynamic subview size");
     return subview.getDynamicSize(unsignedIndex);
   }
bool FPTruncOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   Type a = inputs.front(), b = outputs.front();
   if (auto fa = a.dyn_cast<FloatType>())
     if (auto fb = b.dyn_cast<FloatType>())
       return fa.getWidth() > fb.getWidth();
   return areVectorCastSimpleCompatible(a, b, areCastCompatible);
 }
 
 //===----------------------------------------------------------------------===//
-// GlobalMemrefOp
-//===----------------------------------------------------------------------===//
-
-static void printGlobalMemrefOpTypeAndInitialValue(OpAsmPrinter &p,
-                                                   GlobalMemrefOp op,
-                                                   TypeAttr type,
-                                                   Attribute initialValue) {
-  p << type;
-  if (!op.isExternal()) {
-    p << " = ";
-    if (op.isUninitialized())
-      p << "uninitialized";
-    else
-      p.printAttributeWithoutType(initialValue);
-  }
-}
-
-static ParseResult
-parseGlobalMemrefOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr,
-                                       Attribute &initialValue) {
-  Type type;
-  if (parser.parseType(type))
-    return failure();
-
-  auto memrefType = type.dyn_cast<MemRefType>();
-  if (!memrefType || !memrefType.hasStaticShape())
-    return parser.emitError(parser.getNameLoc())
-           << "type should be static shaped memref, but got " << type;
-  typeAttr = TypeAttr::get(type);
-
-  if (parser.parseOptionalEqual())
-    return success();
-
-  if (succeeded(parser.parseOptionalKeyword("uninitialized"))) {
-    initialValue = UnitAttr::get(parser.getBuilder().getContext());
-    return success();
-  }
-
-  Type tensorType = getTensorTypeFromMemRefType(memrefType);
-  if (parser.parseAttribute(initialValue, tensorType))
-    return failure();
-  if (!initialValue.isa<ElementsAttr>())
-    return parser.emitError(parser.getNameLoc())
-           << "initial value should be a unit or elements attribute";
-  return success();
-}
-
-static LogicalResult verify(GlobalMemrefOp op) {
-  auto memrefType = op.type().dyn_cast<MemRefType>();
-  if (!memrefType || !memrefType.hasStaticShape())
-    return op.emitOpError("type should be static shaped memref, but got ")
-           << op.type();
-
-  // Verify that the initial value, if present, is either a unit attribute or
-  // an elements attribute.
-  if (op.initial_value().hasValue()) {
-    Attribute initValue = op.initial_value().getValue();
-    if (!initValue.isa<UnitAttr>() && !initValue.isa<ElementsAttr>())
-      return op.emitOpError("initial value should be a unit or elements "
-                            "attribute, but got ")
-             << initValue;
-
-    // Check that the type of the initial value is compatible with the type of
-    // the global variable.
-    if (initValue.isa<ElementsAttr>()) {
-      Type initType = initValue.getType();
-      Type tensorType = getTensorTypeFromMemRefType(memrefType);
-      if (initType != tensorType)
-        return op.emitOpError("initial value expected to be of type ")
-               << tensorType << ", but was of type " << initType;
-    }
-  }
-
-  // TODO: verify visibility for declarations.
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
-// GetGlobalMemrefOp
-//===----------------------------------------------------------------------===//
-
-LogicalResult
-GetGlobalMemrefOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
-  // Verify that the result type is same as the type of the referenced
-  // global_memref op.
-  auto global =
-      symbolTable.lookupNearestSymbolFrom<GlobalMemrefOp>(*this, nameAttr());
-  if (!global)
-    return emitOpError("'")
-           << name() << "' does not reference a valid global memref";
-
-  Type resultType = result().getType();
-  if (global.type() != resultType)
-    return emitOpError("result type ")
-           << resultType << " does not match type " << global.type()
-           << " of the global memref @" << name();
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
 // Index cast is applicable from index to integer and backwards.
 bool IndexCastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();

 } // end anonymous namespace.
 
 void LoadOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                          MLIRContext *context) {
   results.insert<LoadOfTensorToMemref>(context);
 }
 
 //===----------------------------------------------------------------------===//
-// MemRefCastOp
-//===----------------------------------------------------------------------===//
-
-Value MemRefCastOp::getViewSource() { return source(); }
-
-bool MemRefCastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
-  if (inputs.size() != 1 || outputs.size() != 1)
-    return false;
-  Type a = inputs.front(), b = outputs.front();
-  auto aT = a.dyn_cast<MemRefType>();
-  auto bT = b.dyn_cast<MemRefType>();
-
-  auto uaT = a.dyn_cast<UnrankedMemRefType>();
-  auto ubT = b.dyn_cast<UnrankedMemRefType>();
-
-  if (aT && bT) {
-    if (aT.getElementType() != bT.getElementType())
-      return false;
-    if (aT.getAffineMaps() != bT.getAffineMaps()) {
-      int64_t aOffset, bOffset;
-      SmallVector<int64_t, 4> aStrides, bStrides;
-      if (failed(getStridesAndOffset(aT, aStrides, aOffset)) ||
-          failed(getStridesAndOffset(bT, bStrides, bOffset)) ||
-          aStrides.size() != bStrides.size())
-        return false;
-
-      // Strides along a dimension/offset are compatible if the value in the
-      // source memref is static and the value in the target memref is the
-      // same. They are also compatible if either one is dynamic (see
-      // description of MemRefCastOp for details).
-      auto checkCompatible = [](int64_t a, int64_t b) {
-        return (a == MemRefType::getDynamicStrideOrOffset() ||
-                b == MemRefType::getDynamicStrideOrOffset() || a == b);
-      };
-      if (!checkCompatible(aOffset, bOffset))
-        return false;
-      for (auto aStride : enumerate(aStrides))
-        if (!checkCompatible(aStride.value(), bStrides[aStride.index()]))
-          return false;
-    }
-    if (aT.getMemorySpace() != bT.getMemorySpace())
-      return false;
-
-    // They must have the same rank, and any specified dimensions must match.
-    if (aT.getRank() != bT.getRank())
-      return false;
-
-    for (unsigned i = 0, e = aT.getRank(); i != e; ++i) {
-      int64_t aDim = aT.getDimSize(i), bDim = bT.getDimSize(i);
-      if (aDim != -1 && bDim != -1 && aDim != bDim)
-        return false;
-    }
-    return true;
-  } else {
-    if (!aT && !uaT)
-      return false;
-    if (!bT && !ubT)
-      return false;
-    // Unranked to unranked casting is unsupported
-    if (uaT && ubT)
-      return false;
-
-    auto aEltType = (aT) ? aT.getElementType() : uaT.getElementType();
-    auto bEltType = (bT) ? bT.getElementType() : ubT.getElementType();
-    if (aEltType != bEltType)
-      return false;
-
-    auto aMemSpace = (aT) ? aT.getMemorySpace() : uaT.getMemorySpace();
-    auto bMemSpace = (bT) ? bT.getMemorySpace() : ubT.getMemorySpace();
-    if (aMemSpace != bMemSpace)
-      return false;
-
-    return true;
-  }
-
-  return false;
-}
-
-OpFoldResult MemRefCastOp::fold(ArrayRef<Attribute> operands) {
-  return succeeded(foldMemRefCast(*this)) ? getResult() : Value();
-}
-
-//===----------------------------------------------------------------------===//
 // MemRefReinterpretCastOp
 //===----------------------------------------------------------------------===//
 
 /// Build a MemRefReinterpretCastOp with all dynamic entries: `staticOffsets`,
 /// `staticSizes` and `staticStrides` are automatically filled with
 /// source-memref-rank sentinel values that encode dynamic entries.
 void mlir::MemRefReinterpretCastOp::build(OpBuilder &b, OperationState &result,
                                           MemRefType resultType, Value source,
OpFoldResult OrOp::fold(ArrayRef<Attribute> operands) {
   if (lhs() == rhs())
     return rhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a | b; });
 }
 
 //===----------------------------------------------------------------------===//
-// PrefetchOp
-//===----------------------------------------------------------------------===//
-
-static void print(OpAsmPrinter &p, PrefetchOp op) {
-  p << PrefetchOp::getOperationName() << " " << op.memref() << '[';
-  p.printOperands(op.indices());
-  p << ']' << ", " << (op.isWrite() ? "write" : "read");
-  p << ", locality<" << op.localityHint();
-  p << ">, " << (op.isDataCache() ? "data" : "instr");
-  p.printOptionalAttrDict(
-      op.getAttrs(),
-      /*elidedAttrs=*/{"localityHint", "isWrite", "isDataCache"});
-  p << " : " << op.getMemRefType();
-}
-
-static ParseResult parsePrefetchOp(OpAsmParser &parser,
-                                   OperationState &result) {
-  OpAsmParser::OperandType memrefInfo;
-  SmallVector<OpAsmParser::OperandType, 4> indexInfo;
-  IntegerAttr localityHint;
-  MemRefType type;
-  StringRef readOrWrite, cacheType;
-
-  auto indexTy = parser.getBuilder().getIndexType();
-  auto i32Type = parser.getBuilder().getIntegerType(32);
-  if (parser.parseOperand(memrefInfo) ||
-      parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square) ||
-      parser.parseComma() || parser.parseKeyword(&readOrWrite) ||
-      parser.parseComma() || parser.parseKeyword("locality") ||
-      parser.parseLess() ||
-      parser.parseAttribute(localityHint, i32Type, "localityHint",
-                            result.attributes) ||
-      parser.parseGreater() || parser.parseComma() ||
-      parser.parseKeyword(&cacheType) || parser.parseColonType(type) ||
-      parser.resolveOperand(memrefInfo, type, result.operands) ||
-      parser.resolveOperands(indexInfo, indexTy, result.operands))
-    return failure();
-
-  if (!readOrWrite.equals("read") && !readOrWrite.equals("write"))
-    return parser.emitError(parser.getNameLoc(),
-                            "rw specifier has to be 'read' or 'write'");
-  result.addAttribute(
-      PrefetchOp::getIsWriteAttrName(),
-      parser.getBuilder().getBoolAttr(readOrWrite.equals("write")));
-
-  if (!cacheType.equals("data") && !cacheType.equals("instr"))
-    return parser.emitError(parser.getNameLoc(),
-                            "cache type has to be 'data' or 'instr'");
-
-  result.addAttribute(
-      PrefetchOp::getIsDataCacheAttrName(),
-      parser.getBuilder().getBoolAttr(cacheType.equals("data")));
-
-  return success();
-}
-
-static LogicalResult verify(PrefetchOp op) {
-  if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
-    return op.emitOpError("too few indices");
-
-  return success();
-}
-
-LogicalResult PrefetchOp::fold(ArrayRef<Attribute> cstOperands,
-                               SmallVectorImpl<OpFoldResult> &results) {
-  // prefetch(memrefcast) -> prefetch
-  return foldMemRefCast(*this);
-}
-
-//===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult RankOp::fold(ArrayRef<Attribute> operands) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
   if (auto shapedType = type.dyn_cast<ShapedType>())
     if (shapedType.hasRank())
OpFoldResult SplatOp::fold(ArrayRef<Attribute> operands) {
   assert(shapedType.getElementType() == constOperand.getType() &&
          "incorrect input attribute type for folding");
 
   // SplatElementsAttr::get treats single value for second arg as being a splat.
   return SplatElementsAttr::get(shapedType, {constOperand});
 }
 
 //===----------------------------------------------------------------------===//
-// StoreOp
-//===----------------------------------------------------------------------===//
-
-static LogicalResult verify(StoreOp op) {
-  if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
-    return op.emitOpError("store index operand count not equal to memref rank");
-
-  return success();
-}
-
-LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
-                            SmallVectorImpl<OpFoldResult> &results) {
-  /// store(memrefcast) -> store
-  return foldMemRefCast(*this);
-}
-
-//===----------------------------------------------------------------------===//
 // SubFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult SubFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a - b; });
 }
 
for (OpFoldResult &ofr : values) {
     // Newly static, move from Value to constant.
     if (auto cstOp = ofr.dyn_cast<Value>().getDefiningOp<ConstantIndexOp>())
       ofr = OpBuilder(cstOp).getIndexAttr(cstOp.getValue());
   }
 }
 
 static void replaceWithNewOp(PatternRewriter &rewriter, SubViewOp op,
                              SubViewOp newOp) {
-  rewriter.replaceOpWithNewOp<MemRefCastOp>(op, newOp, op.getType());
+  rewriter.replaceOpWithNewOp<memref::CastOp>(op, newOp, op.getType());
 }
 
 static void replaceWithNewOp(PatternRewriter &rewriter, SubTensorOp op,
                              SubTensorOp newOp) {
   rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(), newOp);
 }
 
 /// Pattern to rewrite a subview op with constant arguments.
LogicalResult matchAndRewrite(OpType op,
     replaceWithNewOp(rewriter, op, newOp);
 
     return success();
   }
 };
 
 } // end anonymous namespace
 
-/// Determines whether MemRefCastOp casts to a more dynamic version of the
-/// source memref. This is useful to to fold a memref_cast into a consuming op
-/// and implement canonicalization patterns for ops in different dialects that
-/// may consume the results of memref_cast operations. Such foldable memref_cast
-/// operations are typically inserted as `view` and `subview` ops are
-/// canonicalized, to preserve the type compatibility of their uses.
-///
-/// Returns true when all conditions are met:
-/// 1. source and result are ranked memrefs with strided semantics and same
-/// element type and rank.
-/// 2. each of the source's size, offset or stride has more static information
-/// than the corresponding result's size, offset or stride.
-///
-/// Example 1:
-/// ```mlir
-///   %1 = memref_cast %0 : memref<8x16xf32> to memref<?x?xf32>
-///   %2 = consumer %1 ... : memref<?x?xf32> ...
-/// ```
-///
-/// may fold into:
-///
-/// ```mlir
-///   %2 = consumer %0 ... : memref<8x16xf32> ...
-/// ```
-///
-/// Example 2:
-/// ```
-///   %1 = memref_cast %0 : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
-///          to memref<?x?xf32>
-///   consumer %1 : memref<?x?xf32> ...
-/// ```
-///
-/// may fold into:
-///
-/// ```
-///   consumer %0 ... : memref<?x16xf32, affine_map<(i, j)->(16 * i + j)>>
-/// ```
-bool mlir::canFoldIntoConsumerOp(MemRefCastOp castOp) {
-  MemRefType sourceType = castOp.source().getType().dyn_cast<MemRefType>();
-  MemRefType resultType = castOp.getType().dyn_cast<MemRefType>();
-
-  // Requires ranked MemRefType.
-  if (!sourceType || !resultType)
-    return false;
-
-  // Requires same elemental type.
-  if (sourceType.getElementType() != resultType.getElementType())
-    return false;
-
-  // Requires same rank.
-  if (sourceType.getRank() != resultType.getRank())
-    return false;
-
-  // Only fold casts between strided memref forms.
-  int64_t sourceOffset, resultOffset;
-  SmallVector<int64_t, 4> sourceStrides, resultStrides;
-  if (failed(getStridesAndOffset(sourceType, sourceStrides, sourceOffset)) ||
-      failed(getStridesAndOffset(resultType, resultStrides, resultOffset)))
-    return false;
-
-  // If cast is towards more static sizes along any dimension, don't fold.
-  for (auto it : llvm::zip(sourceType.getShape(), resultType.getShape())) {
-    auto ss = std::get<0>(it), st = std::get<1>(it);
-    if (ss != st)
-      if (MemRefType::isDynamic(ss) && !MemRefType::isDynamic(st))
-        return false;
-  }
-
-  // If cast is towards more static offset along any dimension, don't fold.
-  if (sourceOffset != resultOffset)
-    if (MemRefType::isDynamicStrideOrOffset(sourceOffset) &&
-        !MemRefType::isDynamicStrideOrOffset(resultOffset))
-      return false;
-
-  // If cast is towards more static strides along any dimension, don't fold.
-  for (auto it : llvm::zip(sourceStrides, resultStrides)) {
-    auto ss = std::get<0>(it), st = std::get<1>(it);
-    if (ss != st)
-      if (MemRefType::isDynamicStrideOrOffset(ss) &&
-          !MemRefType::isDynamicStrideOrOffset(st))
-        return false;
-  }
-
-  return true;
-}
-
 namespace {
 /// Pattern to rewrite a subview op with MemRefCast arguments.
-/// This essentially pushes memref_cast past its consuming subview when
+/// This essentially pushes memref.cast past its consuming subview when
 /// `canFoldIntoConsumerOp` is true.
 ///
 /// Example:
 /// ```
-///   %0 = memref_cast %V : memref<16x16xf32> to memref<?x?xf32>
+///   %0 = memref.cast %V : memref<16x16xf32> to memref<?x?xf32>
 ///   %1 = subview %0[0, 0][3, 4][1, 1] :
 ///     memref<?x?xf32> to memref<3x4xf32, offset:?, strides:[?, 1]>
 /// ```
 /// is rewritten into:
 /// ```
 ///   %0 = subview %V: memref<16x16xf32> to memref<3x4xf32, #[[map0]]>
-///   %1 = memref_cast %0: memref<3x4xf32, offset:0, strides:[16, 1]> to
+///   %1 = memref.cast %0: memref<3x4xf32, offset:0, strides:[16, 1]> to
 ///     memref<3x4xf32, offset:?, strides:[?, 1]>
 /// ```
 class SubViewOpMemRefCastFolder final : public OpRewritePattern<SubViewOp> {
 public:
   using OpRewritePattern<SubViewOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(SubViewOp subViewOp,
                                 PatternRewriter &rewriter) const override {
     // Any constant operand, just return to let SubViewOpConstantFolder kick in.
     if (llvm::any_of(subViewOp.getOperands(), [](Value operand) {
           return matchPattern(operand, m_ConstantIndex());
         }))
       return failure();
 
-    auto castOp = subViewOp.source().getDefiningOp<MemRefCastOp>();
+    auto castOp = subViewOp.source().getDefiningOp<memref::CastOp>();
     if (!castOp)
       return failure();
 
-    if (!canFoldIntoConsumerOp(castOp))
+    if (!memref::CastOp::canFoldIntoConsumerOp(castOp))
       return failure();
 
     /// Deduce the resultType of the SubViewOp using `inferSubViewResultType` on
     /// the cast source operand type and the SubViewOp static information. This
     /// is the resulting type if the MemRefCastOp were folded.
     auto resultType = SubViewOp::inferResultType(
                           castOp.source().getType().cast<MemRefType>(),
                           extractFromI64ArrayAttr(subViewOp.static_offsets()),
if (rankDiff > 0) {
       }
       resultType = MemRefType::get(projectedShape, resultType.getElementType(),
                                    map, resultType.getMemorySpace());
     }
     Value newSubView = rewriter.create<SubViewOp>(
         subViewOp.getLoc(), resultType, castOp.source(), subViewOp.offsets(),
         subViewOp.sizes(), subViewOp.strides(), subViewOp.static_offsets(),
         subViewOp.static_sizes(), subViewOp.static_strides());
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(subViewOp, subViewOp.getType(),
+    rewriter.replaceOpWithNewOp<memref::CastOp>(subViewOp, subViewOp.getType(),
                                                 newSubView);
     return success();
   }
 };
 } // namespace
 
 void SubViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
   results.insert<OpWithOffsetSizesAndStridesConstantArgumentFolder<SubViewOp>,
LogicalResult matchAndRewrite(TensorToMemrefOp tensorToMemRef,
     auto srcTensorType =
         tensorCastOperand.getOperand().getType().dyn_cast<RankedTensorType>();
     if (!srcTensorType)
       return failure();
     auto memrefType = MemRefType::get(srcTensorType.getShape(),
                                       srcTensorType.getElementType());
     Value memref = rewriter.create<TensorToMemrefOp>(
         tensorToMemRef.getLoc(), memrefType, tensorCastOperand.getOperand());
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(tensorToMemRef,
-                                              tensorToMemRef.getType(), memref);
+    rewriter.replaceOpWithNewOp<memref::CastOp>(
+        tensorToMemRef, tensorToMemRef.getType(), memref);
     return success();
   }
 };
 } // namespace
 
 void TensorToMemrefOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<TensorCastToMemref>(context);
 }
 
 //===----------------------------------------------------------------------===//
-// TransposeOp
-//===----------------------------------------------------------------------===//
-
-/// Build a strided memref type by applying `permutationMap` tp `memRefType`.
-static MemRefType inferTransposeResultType(MemRefType memRefType,
-                                           AffineMap permutationMap) {
-  auto rank = memRefType.getRank();
-  auto originalSizes = memRefType.getShape();
-  // Compute permuted sizes.
-  SmallVector<int64_t, 4> sizes(rank, 0);
-  for (auto en : llvm::enumerate(permutationMap.getResults()))
-    sizes[en.index()] =
-        originalSizes[en.value().cast<AffineDimExpr>().getPosition()];
-
-  // Compute permuted strides.
-  int64_t offset;
-  SmallVector<int64_t, 4> strides;
-  auto res = getStridesAndOffset(memRefType, strides, offset);
-  assert(succeeded(res) && strides.size() == static_cast<unsigned>(rank));
-  (void)res;
-  auto map =
-      makeStridedLinearLayoutMap(strides, offset, memRefType.getContext());
-  map = permutationMap ? map.compose(permutationMap) : map;
-  return MemRefType::Builder(memRefType).setShape(sizes).setAffineMaps(map);
-}
-
-void TransposeOp::build(OpBuilder &b, OperationState &result, Value in,
-                        AffineMapAttr permutation,
-                        ArrayRef<NamedAttribute> attrs) {
-  auto permutationMap = permutation.getValue();
-  assert(permutationMap);
-
-  auto memRefType = in.getType().cast<MemRefType>();
-  // Compute result type.
-  MemRefType resultType = inferTransposeResultType(memRefType, permutationMap);
-
-  build(b, result, resultType, in, attrs);
-  result.addAttribute(TransposeOp::getPermutationAttrName(), permutation);
-}
-
-// transpose $in $permutation attr-dict : type($in) `to` type(results)
-static void print(OpAsmPrinter &p, TransposeOp op) {
-  p << "transpose " << op.in() << " " << op.permutation();
-  p.printOptionalAttrDict(op.getAttrs(),
-                          {TransposeOp::getPermutationAttrName()});
-  p << " : " << op.in().getType() << " to " << op.getType();
-}
-
-static ParseResult parseTransposeOp(OpAsmParser &parser,
-                                    OperationState &result) {
-  OpAsmParser::OperandType in;
-  AffineMap permutation;
-  MemRefType srcType, dstType;
-  if (parser.parseOperand(in) || parser.parseAffineMap(permutation) ||
-      parser.parseOptionalAttrDict(result.attributes) ||
-      parser.parseColonType(srcType) ||
-      parser.resolveOperand(in, srcType, result.operands) ||
-      parser.parseKeywordType("to", dstType) ||
-      parser.addTypeToList(dstType, result.types))
-    return failure();
-
-  result.addAttribute(TransposeOp::getPermutationAttrName(),
-                      AffineMapAttr::get(permutation));
-  return success();
-}
-
-static LogicalResult verify(TransposeOp op) {
-  if (!op.permutation().isPermutation())
-    return op.emitOpError("expected a permutation map");
-  if (op.permutation().getNumDims() != op.getShapedType().getRank())
-    return op.emitOpError(
-        "expected a permutation map of same rank as the input");
-
-  auto srcType = op.in().getType().cast<MemRefType>();
-  auto dstType = op.getType().cast<MemRefType>();
-  auto transposedType = inferTransposeResultType(srcType, op.permutation());
-  if (dstType != transposedType)
-    return op.emitOpError("output type ")
-           << dstType << " does not match transposed input type " << srcType
-           << ", " << transposedType;
-  return success();
-}
-
-OpFoldResult TransposeOp::fold(ArrayRef<Attribute>) {
-  if (succeeded(foldMemRefCast(*this)))
-    return getResult();
-  return {};
-}
-
-//===----------------------------------------------------------------------===//
 // TruncateIOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TruncateIOp op) {
   auto srcType = getElementTypeOrSelf(op.getOperand().getType());
   auto dstType = getElementTypeOrSelf(op.getType());
 
   if (srcType.isa<IndexType>())
OpFoldResult UnsignedRemIOp::fold(ArrayRef<Attribute> operands) {
 
   auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
   if (!lhs)
     return {};
   return IntegerAttr::get(lhs.getType(), lhs.getValue().urem(rhsValue));
 }
 
 //===----------------------------------------------------------------------===//
-// ViewOp
-//===----------------------------------------------------------------------===//
-
-static ParseResult parseViewOp(OpAsmParser &parser, OperationState &result) {
-  OpAsmParser::OperandType srcInfo;
-  SmallVector<OpAsmParser::OperandType, 1> offsetInfo;
-  SmallVector<OpAsmParser::OperandType, 4> sizesInfo;
-  auto indexType = parser.getBuilder().getIndexType();
-  Type srcType, dstType;
-  llvm::SMLoc offsetLoc;
-  if (parser.parseOperand(srcInfo) || parser.getCurrentLocation(&offsetLoc) ||
-      parser.parseOperandList(offsetInfo, OpAsmParser::Delimiter::Square))
-    return failure();
-
-  if (offsetInfo.size() != 1)
-    return parser.emitError(offsetLoc) << "expects 1 offset operand";
-
-  return failure(
-      parser.parseOperandList(sizesInfo, OpAsmParser::Delimiter::Square) ||
-      parser.parseOptionalAttrDict(result.attributes) ||
-      parser.parseColonType(srcType) ||
-      parser.resolveOperand(srcInfo, srcType, result.operands) ||
-      parser.resolveOperands(offsetInfo, indexType, result.operands) ||
-      parser.resolveOperands(sizesInfo, indexType, result.operands) ||
-      parser.parseKeywordType("to", dstType) ||
-      parser.addTypeToList(dstType, result.types));
-}
-
-static void print(OpAsmPrinter &p, ViewOp op) {
-  p << op.getOperationName() << ' ' << op.getOperand(0) << '[';
-  p.printOperand(op.byte_shift());
-  p << "][" << op.sizes() << ']';
-  p.printOptionalAttrDict(op.getAttrs());
-  p << " : " << op.getOperand(0).getType() << " to " << op.getType();
-}
-
-static LogicalResult verify(ViewOp op) {
-  auto baseType = op.getOperand(0).getType().cast<MemRefType>();
-  auto viewType = op.getType();
-
-  // The base memref should have identity layout map (or none).
-  if (baseType.getAffineMaps().size() > 1 ||
-      (baseType.getAffineMaps().size() == 1 &&
-       !baseType.getAffineMaps()[0].isIdentity()))
-    return op.emitError("unsupported map for base memref type ") << baseType;
-
-  // The result memref should have identity layout map (or none).
-  if (viewType.getAffineMaps().size() > 1 ||
-      (viewType.getAffineMaps().size() == 1 &&
-       !viewType.getAffineMaps()[0].isIdentity()))
-    return op.emitError("unsupported map for result memref type ") << viewType;
-
-  // The base memref and the view memref should be in the same memory space.
-  if (baseType.getMemorySpace() != viewType.getMemorySpace())
-    return op.emitError("different memory spaces specified for base memref "
-                        "type ")
-           << baseType << " and view memref type " << viewType;
-
-  // Verify that we have the correct number of sizes for the result type.
-  unsigned numDynamicDims = viewType.getNumDynamicDims();
-  if (op.sizes().size() != numDynamicDims)
-    return op.emitError("incorrect number of size operands for type ")
-           << viewType;
-
-  return success();
-}
-
-Value ViewOp::getViewSource() { return source(); }
-
-namespace {
-
-struct ViewOpShapeFolder : public OpRewritePattern<ViewOp> {
-  using OpRewritePattern<ViewOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(ViewOp viewOp,
-                                PatternRewriter &rewriter) const override {
-    // Return if none of the operands are constants.
-    if (llvm::none_of(viewOp.getOperands(), [](Value operand) {
-          return matchPattern(operand, m_ConstantIndex());
-        }))
-      return failure();
-
-    // Get result memref type.
-    auto memrefType = viewOp.getType();
-
-    // Get offset from old memref view type 'memRefType'.
-    int64_t oldOffset;
-    SmallVector<int64_t, 4> oldStrides;
-    if (failed(getStridesAndOffset(memrefType, oldStrides, oldOffset)))
-      return failure();
-    assert(oldOffset == 0 && "Expected 0 offset");
-
-    SmallVector<Value, 4> newOperands;
-
-    // Offset cannot be folded into result type.
-
-    // Fold any dynamic dim operands which are produced by a constant.
-    SmallVector<int64_t, 4> newShapeConstants;
-    newShapeConstants.reserve(memrefType.getRank());
-
-    unsigned dynamicDimPos = 0;
-    unsigned rank = memrefType.getRank();
-    for (unsigned dim = 0, e = rank; dim < e; ++dim) {
-      int64_t dimSize = memrefType.getDimSize(dim);
-      // If this is already static dimension, keep it.
-      if (!ShapedType::isDynamic(dimSize)) {
-        newShapeConstants.push_back(dimSize);
-        continue;
-      }
-      auto *defOp = viewOp.sizes()[dynamicDimPos].getDefiningOp();
-      if (auto constantIndexOp = dyn_cast_or_null<ConstantIndexOp>(defOp)) {
-        // Dynamic shape dimension will be folded.
-        newShapeConstants.push_back(constantIndexOp.getValue());
-      } else {
-        // Dynamic shape dimension not folded; copy operand from old memref.
-        newShapeConstants.push_back(dimSize);
-        newOperands.push_back(viewOp.sizes()[dynamicDimPos]);
-      }
-      dynamicDimPos++;
-    }
-
-    // Create new memref type with constant folded dims.
-    MemRefType newMemRefType =
-        MemRefType::Builder(memrefType).setShape(newShapeConstants);
-    // Nothing new, don't fold.
-    if (newMemRefType == memrefType)
-      return failure();
-
-    // Create new ViewOp.
-    auto newViewOp = rewriter.create<ViewOp>(viewOp.getLoc(), newMemRefType,
-                                             viewOp.getOperand(0),
-                                             viewOp.byte_shift(), newOperands);
-    // Insert a cast so we have the same type as the old memref type.
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(viewOp, newViewOp,
-                                              viewOp.getType());
-    return success();
-  }
-};
-
-struct ViewOpMemrefCastFolder : public OpRewritePattern<ViewOp> {
-  using OpRewritePattern<ViewOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(ViewOp viewOp,
-                                PatternRewriter &rewriter) const override {
-    Value memrefOperand = viewOp.getOperand(0);
-    MemRefCastOp memrefCastOp = memrefOperand.getDefiningOp<MemRefCastOp>();
-    if (!memrefCastOp)
-      return failure();
-    Value allocOperand = memrefCastOp.getOperand();
-    AllocOp allocOp = allocOperand.getDefiningOp<AllocOp>();
-    if (!allocOp)
-      return failure();
-    rewriter.replaceOpWithNewOp<ViewOp>(viewOp, viewOp.getType(), allocOperand,
-                                        viewOp.byte_shift(), viewOp.sizes());
-    return success();
-  }
-};
-
-} // end anonymous namespace
-
-void ViewOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
-                                         MLIRContext *context) {
-  results.insert<ViewOpShapeFolder, ViewOpMemrefCastFolder>(context);
-}
-
-//===----------------------------------------------------------------------===//
 // XOrOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult XOrOp::fold(ArrayRef<Attribute> operands) {
   /// xor(x, 0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
   /// xor(x,x) -> 0

mlir/lib/Dialect/StandardOps/Transforms/TensorConstantBufferize.cpp

 //===- Bufferize.cpp - Bufferization for std ops --------------------------===//
 //
 // 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 bufferization of tensor-valued std.constant ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/Transforms/Bufferize.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace {
 // This class creates global ops for all tensor-valued constants in the program.
 // It creates them with pretty names and makes sure that duplicate globals
 // aren't created.
 class GlobalCreator {
 public:
   explicit GlobalCreator(ModuleOp module);
-  GlobalMemrefOp getGlobalFor(Attribute attr) {
+  memref::GlobalOp getGlobalFor(Attribute attr) {
     assert(globals.find(attr) != globals.end() && "unknown constant attr");
     return globals[attr];
   }
 
 private:
-  DenseMap<Attribute, GlobalMemrefOp> globals;
+  DenseMap<Attribute, memref::GlobalOp> globals;
 };
 
 GlobalCreator::GlobalCreator(ModuleOp module) {
   BufferizeTypeConverter typeConverter;
   // Create a builder without an insertion point. We will insert using the
   // symbol table to guarantee unique names.
   OpBuilder globalBuilder(module.getContext());
   SymbolTable symbolTable(module);
if (it != globals.end())
       return;
 
     // Create a pretty name.
     SmallString<64> buf;
     llvm::raw_svector_ostream os(buf);
     interleave(type.getShape(), os, "x");
     os << "x" << type.getElementType();
 
-    auto global = globalBuilder.create<GlobalMemrefOp>(
+    auto global = globalBuilder.create<memref::GlobalOp>(
         op.getLoc(), (Twine("__constant_") + os.str()).str(),
         /*sym_visibility=*/globalBuilder.getStringAttr("private"),
         /*type=*/
         TypeAttr::get(typeConverter.convertType(type)), /*initial_value=*/
         op.getValue().cast<ElementsAttr>(), /*constant=*/true);
     symbolTable.insert(global);
     // The symbol table inserts at the end of the module, but globals are a bit
     // nicer if they are at the beginning.
public:
   LogicalResult
   matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = op.getType().dyn_cast<RankedTensorType>();
     if (!type)
       return failure();
 
     auto globalMemref = globals.getGlobalFor(op.value());
-    rewriter.replaceOpWithNewOp<GetGlobalMemrefOp>(op, globalMemref.type(),
+    rewriter.replaceOpWithNewOp<memref::GetGlobalOp>(op, globalMemref.type(),
                                                      globalMemref.getName());
     return success();
   }
   GlobalCreator &globals;
 };
 } // namespace
 
 namespace {
 struct TensorConstantBufferizePass

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization for `tensor` dialect ops -------------===//
 //
 // 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 bufferization of `tensor` dialect ops
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Bufferize.h"
 #include "PassDetail.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Transforms/Passes.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace {
 class BufferizeCastOp : public OpConversionPattern<tensor::CastOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(tensor::CastOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto resultType = getTypeConverter()->convertType(op.getType());
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(op, resultType, operands[0]);
+    rewriter.replaceOpWithNewOp<memref::CastOp>(op, resultType, operands[0]);
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeExtractOp : public OpConversionPattern<tensor::ExtractOp> {
 public:

 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(tensor::FromElementsOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     int numberOfElements = op.elements().size();
     auto resultType = MemRefType::get(
         {numberOfElements}, op.getType().cast<TensorType>().getElementType());
-    Value result = rewriter.create<AllocOp>(op.getLoc(), resultType);
+    Value result = rewriter.create<memref::AllocOp>(op.getLoc(), resultType);
     for (auto element : llvm::enumerate(op.elements())) {
       Value index =
           rewriter.create<ConstantIndexOp>(op.getLoc(), element.index());
-      rewriter.create<StoreOp>(op.getLoc(), element.value(), result, index);
+      rewriter.create<memref::StoreOp>(op.getLoc(), element.value(), result,
+                                       index);
     }
     rewriter.replaceOp(op, {result});
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeGenerateOp : public OpConversionPattern<tensor::GenerateOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(tensor::GenerateOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     // Allocate memory.
     Location loc = op.getLoc();
     tensor::GenerateOp::Adaptor transformed(operands);
     RankedTensorType tensorType = op.getType().cast<RankedTensorType>();
     MemRefType memrefType =
         MemRefType::get(tensorType.getShape(), tensorType.getElementType());
-    Value result =
-        rewriter.create<AllocOp>(loc, memrefType, transformed.dynamicExtents());
+    Value result = rewriter.create<memref::AllocOp>(
+        loc, memrefType, transformed.dynamicExtents());
 
     // Collect loop bounds.
     int64_t rank = tensorType.getRank();
     Value zero = rewriter.create<ConstantIndexOp>(loc, 0);
     Value one = rewriter.create<ConstantIndexOp>(loc, 1);
     SmallVector<Value, 4> lowerBounds(rank, zero);
     SmallVector<Value, 4> steps(rank, one);
     SmallVector<Value, 4> upperBounds;
matchAndRewrite(tensor::GenerateOp op, ArrayRef<Value> operands,
     Block *parallelBody = parallel.getBody();
     rewriter.mergeBlockBefore(op.getBody(), parallelBody->getTerminator(),
                               parallelBody->getArguments());
     // Replace the inlined yield op with a store op. The scf.parallel's builder
     // already populated an scf.yield at the end, so we don't need to worry
     // about creating that.
     Operation *elementYield = parallelBody->getTerminator()->getPrevNode();
     rewriter.setInsertionPointAfter(elementYield);
-    rewriter.replaceOpWithNewOp<StoreOp>(elementYield,
-                                         elementYield->getOperands()[0], result,
-                                         parallelBody->getArguments());
+    rewriter.replaceOpWithNewOp<memref::StoreOp>(
+        elementYield, elementYield->getOperands()[0], result,
 
     rewriter.replaceOp(op, {result});
     return success();
   }
 };
 } // namespace
 
 void mlir::populateTensorBufferizePatterns(
void runOnFunction() override {
     OwningRewritePatternList patterns;
     ConversionTarget target(*context);
 
     populateBufferizeMaterializationLegality(target);
 
     populateTensorBufferizePatterns(context, typeConverter, patterns);
     target.addIllegalOp<tensor::CastOp, tensor::ExtractOp,
                         tensor::FromElementsOp, tensor::GenerateOp>();
+    target.addLegalDialect<memref::MemRefDialect>();
     target.addLegalDialect<StandardOpsDialect>();
     target.addLegalDialect<scf::SCFDialect>();
 
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createTensorBufferizePass() {
   return std::make_unique<TensorBufferizePass>();
 }

mlir/lib/Dialect/Vector/VectorOps.cpp

 //===- VectorOps.cpp - MLIR Vector Dialect Operations ---------------------===//
 //
 // 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 convenience types for working with super-vectorization
 // operations, in particular super-vector loads and stores.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Vector/VectorOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
static LogicalResult verify(TransferReadOp op) {
   return verifyPermutationMap(permutationMap,
                               [&op](Twine t) { return op.emitOpError(t); });
 }
 
 /// This is a common class used for patterns of the form
 /// ```
 ///    someop(memrefcast) -> someop
 /// ```
-/// It folds the source of the memref_cast into the root operation directly.
+/// It folds the source of the memref.cast into the root operation directly.
 static LogicalResult foldMemRefCast(Operation *op) {
   bool folded = false;
   for (OpOperand &operand : op->getOpOperands()) {
-    auto castOp = operand.get().getDefiningOp<MemRefCastOp>();
-    if (castOp && canFoldIntoConsumerOp(castOp)) {
+    auto castOp = operand.get().getDefiningOp<memref::CastOp>();
+    if (castOp && memref::CastOp::canFoldIntoConsumerOp(castOp)) {
       operand.set(castOp.getOperand());
       folded = true;
     }
   }
   return success(folded);
 }
 
 template <typename TransferOp>

mlir/lib/Dialect/Vector/VectorTransforms.cpp

 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "mlir/Dialect/Affine/EDSC/Builders.h"
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorTransforms.h"
 #include "mlir/Dialect/Vector/VectorUtils.h"

 /// return null; otherwise:
 ///   1. if `aT` and `bT` are cast-compatible, return `aT`.
 ///   2. else return a new MemRefType obtained by iterating over the shape and
 ///   strides and:
 ///     a. keeping the ones that are static and equal across `aT` and `bT`.
 ///     b. using a dynamic shape and/or stride for the dimensions that don't
 ///        agree.
 static MemRefType getCastCompatibleMemRefType(MemRefType aT, MemRefType bT) {
-  if (MemRefCastOp::areCastCompatible(aT, bT))
+  if (memref::CastOp::areCastCompatible(aT, bT))
     return aT;
   if (aT.getRank() != bT.getRank())
     return MemRefType();
   int64_t aOffset, bOffset;
   SmallVector<int64_t, 4> aStrides, bStrides;
   if (failed(getStridesAndOffset(aT, aStrides, aOffset)) ||
       failed(getStridesAndOffset(bT, bStrides, bOffset)) ||
       aStrides.size() != bStrides.size())

 }
 
 /// Given an `xferOp` for which:
 ///   1. `inBoundsCond` and a `compatibleMemRefType` have been computed.
 ///   2. a memref of single vector `alloc` has been allocated.
 /// Produce IR resembling:
 /// ```
 ///    %1:3 = scf.if (%inBounds) {
-///      memref_cast %A: memref<A...> to compatibleMemRefType
+///      memref.cast %A: memref<A...> to compatibleMemRefType
 ///      scf.yield %view, ... : compatibleMemRefType, index, index
 ///    } else {
 ///      %2 = linalg.fill(%alloc, %pad)
 ///      %3 = subview %view [...][...][...]
 ///      linalg.copy(%3, %alloc)
-///      memref_cast %alloc: memref<B...> to compatibleMemRefType
+///      memref.cast %alloc: memref<B...> to compatibleMemRefType
 ///      scf.yield %4, ... : compatibleMemRefType, index, index
 ///   }
 /// ```
 /// Return the produced scf::IfOp.
 static scf::IfOp createScopedFullPartialLinalgCopy(
     vector::TransferReadOp xferOp, TypeRange returnTypes, Value inBoundsCond,
     MemRefType compatibleMemRefType, Value alloc) {
   using namespace edsc;
   using namespace edsc::intrinsics;
   scf::IfOp fullPartialIfOp;
   Value zero = std_constant_index(0);
   Value memref = xferOp.source();
   conditionBuilder(
       returnTypes, inBoundsCond,
       [&]() -> scf::ValueVector {
         Value res = memref;
         if (compatibleMemRefType != xferOp.getShapedType())
-          res = std_memref_cast(memref, compatibleMemRefType);
+          res = memref_cast(memref, compatibleMemRefType);
         scf::ValueVector viewAndIndices{res};
         viewAndIndices.insert(viewAndIndices.end(), xferOp.indices().begin(),
                               xferOp.indices().end());
         return viewAndIndices;
       },
       [&]() -> scf::ValueVector {
         linalg_fill(alloc, xferOp.padding());
         // Take partial subview of memref which guarantees no dimension
         // overflows.
         Value memRefSubView = createScopedSubViewIntersection(
             cast<VectorTransferOpInterface>(xferOp.getOperation()), alloc);
         linalg_copy(memRefSubView, alloc);
-        Value casted = std_memref_cast(alloc, compatibleMemRefType);
+        Value casted = memref_cast(alloc, compatibleMemRefType);
         scf::ValueVector viewAndIndices{casted};
         viewAndIndices.insert(viewAndIndices.end(), xferOp.getTransferRank(),
                               zero);
         return viewAndIndices;
       },
       &fullPartialIfOp);
   return fullPartialIfOp;
 }
 
 /// Given an `xferOp` for which:
 ///   1. `inBoundsCond` and a `compatibleMemRefType` have been computed.
 ///   2. a memref of single vector `alloc` has been allocated.
 /// Produce IR resembling:
 /// ```
 ///    %1:3 = scf.if (%inBounds) {
-///      memref_cast %A: memref<A...> to compatibleMemRefType
+///      memref.cast %A: memref<A...> to compatibleMemRefType
 ///      scf.yield %view, ... : compatibleMemRefType, index, index
 ///    } else {
 ///      %2 = vector.transfer_read %view[...], %pad : memref<A...>, vector<...>
 ///      %3 = vector.type_cast %extra_alloc :
 ///        memref<...> to memref<vector<...>>
 ///      store %2, %3[] : memref<vector<...>>
-///      %4 = memref_cast %alloc: memref<B...> to compatibleMemRefType
+///      %4 = memref.cast %alloc: memref<B...> to compatibleMemRefType
 ///      scf.yield %4, ... : compatibleMemRefType, index, index
 ///   }
 /// ```
 /// Return the produced scf::IfOp.
 static scf::IfOp createScopedFullPartialVectorTransferRead(
     vector::TransferReadOp xferOp, TypeRange returnTypes, Value inBoundsCond,
     MemRefType compatibleMemRefType, Value alloc) {
   using namespace edsc;
   using namespace edsc::intrinsics;
   scf::IfOp fullPartialIfOp;
   Value zero = std_constant_index(0);
   Value memref = xferOp.source();
   conditionBuilder(
       returnTypes, inBoundsCond,
       [&]() -> scf::ValueVector {
         Value res = memref;
         if (compatibleMemRefType != xferOp.getShapedType())
-          res = std_memref_cast(memref, compatibleMemRefType);
+          res = memref_cast(memref, compatibleMemRefType);
         scf::ValueVector viewAndIndices{res};
         viewAndIndices.insert(viewAndIndices.end(), xferOp.indices().begin(),
                               xferOp.indices().end());
         return viewAndIndices;
       },
       [&]() -> scf::ValueVector {
         Operation *newXfer =
             ScopedContext::getBuilderRef().clone(*xferOp.getOperation());
         Value vector = cast<VectorTransferOpInterface>(newXfer).vector();
-        std_store(vector, vector_type_cast(
+        memref_store(vector, vector_type_cast(
                                  MemRefType::get({}, vector.getType()), alloc));
 
-        Value casted = std_memref_cast(alloc, compatibleMemRefType);
+        Value casted = memref_cast(alloc, compatibleMemRefType);
         scf::ValueVector viewAndIndices{casted};
         viewAndIndices.insert(viewAndIndices.end(), xferOp.getTransferRank(),
                               zero);
 
         return viewAndIndices;
       },
       &fullPartialIfOp);
   return fullPartialIfOp;

 /// Example (a 2-D vector.transfer_read):
 /// ```
 ///    %1 = vector.transfer_read %0[...], %pad : memref<A...>, vector<...>
 /// ```
 /// is transformed into:
 /// ```
 ///    %1:3 = scf.if (%inBounds) {
 ///      // fastpath, direct cast
-///      memref_cast %A: memref<A...> to compatibleMemRefType
+///      memref.cast %A: memref<A...> to compatibleMemRefType
 ///      scf.yield %view : compatibleMemRefType, index, index
 ///    } else {
 ///      // slowpath, masked vector.transfer or linalg.copy.
-///      memref_cast %alloc: memref<B...> to compatibleMemRefType
+///      memref.cast %alloc: memref<B...> to compatibleMemRefType
 ///      scf.yield %4 : compatibleMemRefType, index, index
 //     }
 ///    %0 = vector.transfer_read %1#0[%1#1, %1#2] {masked = [false ... false]}
 /// ```
 /// where `alloc` is a top of the function alloca'ed buffer of one vector.
 ///
 /// Preconditions:
 ///  1. `xferOp.permutation_map()` must be a minor identity map
LogicalResult mlir::vector::splitFullAndPartialTransfer(
   // Top of the function `alloc` for transient storage.
   Value alloc;
   {
     FuncOp funcOp = xferOp->getParentOfType<FuncOp>();
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPointToStart(&funcOp.getRegion().front());
     auto shape = xferOp.getVectorType().getShape();
     Type elementType = xferOp.getVectorType().getElementType();
-    alloc = std_alloca(MemRefType::get(shape, elementType), ValueRange{},
+    alloc = memref_alloca(MemRefType::get(shape, elementType), ValueRange{},
                           b.getI64IntegerAttr(32));
   }
 
   MemRefType compatibleMemRefType =
       getCastCompatibleMemRefType(xferOp.getShapedType().cast<MemRefType>(),
                                   alloc.getType().cast<MemRefType>());
 
   // Read case: full fill + partial copy -> unmasked vector.xfer_read.
   SmallVector<Type, 4> returnTypes(1 + xferOp.getTransferRank(),

mlir/lib/Transforms/BufferDeallocation.cpp

 // the resulting code will be invalid with respect to program semantics.
 // However, structured control-flow loops are fully supported. Furthermore, it
 // doesn't accept functions which return buffers already.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/StandardOps/Utils/Utils.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/BufferUtils.h"
 #include "mlir/Transforms/Passes.h"
Value introduceBufferCopy(Value sourceValue, Operation *terminator) {
 
     // Extract information about dynamically shaped types by
     // extracting their dynamic dimensions.
     auto dynamicOperands =
         getDynOperands(terminator->getLoc(), sourceValue, builder);
 
     // TODO: provide a generic interface to create dialect-specific
     // Alloc and CopyOp nodes.
-    auto alloc = builder.create<AllocOp>(terminator->getLoc(), memRefType,
-                                         dynamicOperands);
+    auto alloc = builder.create<memref::AllocOp>(terminator->getLoc(),
+                                                 memRefType, dynamicOperands);
 
     // Create a new copy operation that copies to contents of the old
     // allocation to the new one.
     builder.create<linalg::CopyOp>(terminator->getLoc(), sourceValue, alloc);
 
     // Remember the copy of original source value.
     copiedValues.insert(alloc);
     return alloc;
for (const BufferPlacementAllocs::AllocEntry &entry : allocs) {
       } else {
         // If the Dealloc position is at the terminator operation of the
         // block, then the value should escape from a deallocation.
         Operation *nextOp = endOperation->getNextNode();
         if (!nextOp)
           continue;
         // If there is no dealloc node, insert one in the right place.
         OpBuilder builder(nextOp);
-        builder.create<DeallocOp>(alloc.getLoc(), alloc);
+        builder.create<memref::DeallocOp>(alloc.getLoc(), alloc);
       }
     }
   }
 
   /// The dominator info to find the appropriate start operation to move the
   /// allocs.
   DominanceInfo dominators;
 

mlir/lib/Transforms/BufferOptimizations.cpp

 //===- BufferOptimizations.cpp - pre-pass optimizations for bufferization -===//
 //
 // 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 three optimization passes. The first two
 // passes try to move alloc nodes out of blocks to reduce the number of
 // allocations and copies during buffer deallocation. The third pass tries to
 // convert heap-based allocations to stack-based allocations, if possible.
 
 #include "PassDetail.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/BufferUtils.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 /// Returns true if the given operation implements a known high-level region-
 /// based control-flow interface.
 static bool isKnownControlFlowInterface(Operation *op) {
   return isa<LoopLikeOpInterface, RegionBranchOpInterface>(op);
 }
 
 /// Check if the size of the allocation is less than the given size. The
 /// transformation is only applied to small buffers since large buffers could
 /// exceed the stack space.
 static bool defaultIsSmallAlloc(Value alloc, unsigned maximumSizeInBytes,
                                 unsigned bitwidthOfIndexType,
                                 unsigned maxRankOfAllocatedMemRef) {
   auto type = alloc.getType().dyn_cast<ShapedType>();
-  if (!type || !alloc.getDefiningOp<AllocOp>())
+  if (!type || !alloc.getDefiningOp<memref::AllocOp>())
     return false;
   if (!type.hasStaticShape()) {
     // Check if the dynamic shape dimension of the alloc is produced by RankOp.
     // If this is the case, it is likely to be small. Furthermore, the dimension
     // is limited to the maximum rank of the allocated memref to avoid large
     // values by multiplying several small values.
     if (type.getRank() <= maxRankOfAllocatedMemRef) {
       return llvm::all_of(
for (BufferPlacementAllocs::AllocEntry &entry : allocs) {
         continue;
 
       Operation *startOperation = BufferPlacementAllocs::getStartOperation(
           alloc, alloc.getParentBlock(), liveness);
       // Build a new alloca that is associated with its parent
       // `AutomaticAllocationScope` determined during the initialization phase.
       OpBuilder builder(startOperation);
       Operation *allocOp = alloc.getDefiningOp();
-      Operation *alloca = builder.create<AllocaOp>(
+      Operation *alloca = builder.create<memref::AllocaOp>(
           alloc.getLoc(), alloc.getType().cast<MemRefType>(),
           allocOp->getOperands());
 
       // Replace the original alloc by a newly created alloca.
       allocOp->replaceAllUsesWith(alloca);
       allocOp->erase();
     }
   }

mlir/lib/Transforms/BufferResultsToOutParams.cpp

 //===- BufferResultsToOutParams.cpp - Calling convention conversion -------===//
 //
 // 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 "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 // Updates the func op and entry block.
module.walk([&](CallOp op) {
     OpBuilder builder(op);
     for (Value memref : replaceWithOutParams) {
       if (!memref.getType().cast<BaseMemRefType>().hasStaticShape()) {
         op.emitError()
             << "cannot create out param for dynamically shaped result";
         didFail = true;
         return;
       }
-      Value outParam = builder.create<AllocOp>(
+      Value outParam = builder.create<memref::AllocOp>(
           op.getLoc(), memref.getType().cast<MemRefType>());
       memref.replaceAllUsesWith(outParam);
       outParams.push_back(outParam);
     }
 
     auto newOperands = llvm::to_vector<6>(op.getOperands());
     newOperands.append(outParams.begin(), outParams.end());
     auto newResultTypes = llvm::to_vector<6>(llvm::map_range(

mlir/lib/Transforms/LoopFusion.cpp

 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Analysis/AffineAnalysis.h"
 #include "mlir/Analysis/AffineStructures.h"
 #include "mlir/Analysis/LoopAnalysis.h"
 #include "mlir/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/LoopFusionUtils.h"
 #include "mlir/Transforms/LoopUtils.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 #include "llvm/ADT/DenseMap.h"
auto newMemRefType = MemRefType::get(newShape, oldMemRefType.getElementType(),
                                        {}, newMemSpace);
 
   // Create new private memref for fused loop 'forOp'. 'newShape' is always
   // a constant shape.
   // TODO: Create/move alloc ops for private memrefs closer to their
   // consumer loop nests to reduce their live range. Currently they are added
   // at the beginning of the function, because loop nests can be reordered
   // during the fusion pass.
-  Value newMemRef = top.create<AllocOp>(forOp.getLoc(), newMemRefType);
+  Value newMemRef = top.create<memref::AllocOp>(forOp.getLoc(), newMemRefType);
 
   // Build an AffineMap to remap access functions based on lower bound offsets.
   SmallVector<AffineExpr, 4> remapExprs;
   remapExprs.reserve(rank);
   for (unsigned i = 0; i < rank; i++) {
     auto dimExpr = b.getAffineDimExpr(outerIVs.size() + i);
 
     auto remapExpr =
for (auto &pair : mdg->memrefEdgeCount) {
       if (pair.second > 0)
         continue;
       auto memref = pair.first;
       // Skip if there exist other uses (return operation or function calls).
       if (!memref.use_empty())
         continue;
       // Use list expected to match the dep graph info.
       auto *op = memref.getDefiningOp();
-      if (isa_and_nonnull<AllocOp>(op))
+      if (isa_and_nonnull<memref::AllocOp>(op))
         op->erase();
     }
   }
 };
 
 } // end anonymous namespace
 
 void LoopFusion::runOnFunction() {

mlir/lib/Transforms/MemRefDataFlowOpt.cpp

 // dead memref store's and perform more complex forwarding when support for
 // SSA scalars live out of 'affine.for'/'affine.if' statements is available.
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Analysis/AffineAnalysis.h"
 #include "mlir/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include <algorithm>
 
 #define DEBUG_TYPE "memref-dataflow-opt"
 
if (llvm::all_of(depSrcStores, [&](Operation *depStore) {
       break;
     }
   }
   if (!lastWriteStoreOp)
     return;
 
   // Perform the actual store to load forwarding.
   Value storeVal =
       cast<AffineWriteOpInterface>(lastWriteStoreOp).getValueToStore();
   loadOp.getValue().replaceAllUsesWith(storeVal);
   // Record the memref for a later sweep to optimize away.
   memrefsToErase.insert(loadOp.getMemRef());
   // Record this to erase later.
   loadOpsToErase.push_back(loadOp);
 }
 
 void MemRefDataFlowOpt::runOnFunction() {
for (auto *loadOp : loadOpsToErase)
     loadOp->erase();
 
   // Check if the store fwd'ed memrefs are now left with only stores and can
   // thus be completely deleted. Note: the canonicalize pass should be able
   // to do this as well, but we'll do it here since we collected these anyway.
   for (auto memref : memrefsToErase) {
     // If the memref hasn't been alloc'ed in this function, skip.
     Operation *defOp = memref.getDefiningOp();
-    if (!defOp || !isa<AllocOp>(defOp))
+    if (!defOp || !isa<memref::AllocOp>(defOp))
       // TODO: if the memref was returned by a 'call' operation, we
       // could still erase it if the call had no side-effects.
       continue;
     if (llvm::any_of(memref.getUsers(), [&](Operation *ownerOp) {
-          return !isa<AffineWriteOpInterface, DeallocOp>(ownerOp);
+          return !isa<AffineWriteOpInterface, memref::DeallocOp>(ownerOp);
         }))
       continue;
 
     // Erase all stores, the dealloc, and the alloc on the memref.
     for (auto *user : llvm::make_early_inc_range(memref.getUsers()))
       user->erase();
     defOp->erase();
   }
 }

mlir/lib/Transforms/NormalizeMemRefs.cpp

 //===- NormalizeMemRefs.cpp -----------------------------------------------===//
 //
 // 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 an interprocedural pass to normalize memrefs to have
 // identity layout maps.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/Utils.h"
 #include "llvm/ADT/SmallSet.h"
 
 #define DEBUG_TYPE "normalize-memrefs"
 
 using namespace mlir;
 

 /// argument or return type, we still label the entire function as
 /// non-normalizable. We assume external functions to be normalizable.
 bool NormalizeMemRefs::areMemRefsNormalizable(FuncOp funcOp) {
   // We assume external functions to be normalizable.
   if (funcOp.isExternal())
     return true;
 
   if (funcOp
-          .walk([&](AllocOp allocOp) -> WalkResult {
+          .walk([&](memref::AllocOp allocOp) -> WalkResult {
             Value oldMemRef = allocOp.getResult();
             if (!isMemRefNormalizable(oldMemRef.getUsers()))
               return WalkResult::interrupt();
             return WalkResult::advance();
           })
           .wasInterrupted())
     return false;
 

 /// Normalizes the memrefs within a function which includes those arising as a
 /// result of AllocOps, CallOps and function's argument. The ModuleOp argument
 /// is used to help update function's signature after normalization.
 void NormalizeMemRefs::normalizeFuncOpMemRefs(FuncOp funcOp,
                                               ModuleOp moduleOp) {
   // Turn memrefs' non-identity layouts maps into ones with identity. Collect
   // alloc ops first and then process since normalizeMemRef replaces/erases ops
   // during memref rewriting.
-  SmallVector<AllocOp, 4> allocOps;
-  funcOp.walk([&](AllocOp op) { allocOps.push_back(op); });
-  for (AllocOp allocOp : allocOps)
+  SmallVector<memref::AllocOp, 4> allocOps;
+  funcOp.walk([&](memref::AllocOp op) { allocOps.push_back(op); });
+  for (memref::AllocOp allocOp : allocOps)
     (void)normalizeMemRef(allocOp);
 
   // We use this OpBuilder to create new memref layout later.
   OpBuilder b(funcOp);
 
   FunctionType functionType = funcOp.getType();
   SmallVector<Type, 8> inputTypes;
   // Walk over each argument of a function to perform memref normalization (if

mlir/lib/Transforms/PipelineDataTransfer.cpp

static bool doubleBuffer(Value oldMemRef, AffineForOp forOp) {
 
   // The double buffer is allocated right before 'forOp'.
   OpBuilder bOuter(forOp);
   // Put together alloc operands for any dynamic dimensions of the memref.
 
   auto allocOperands = getDynOperands(forOp.getLoc(), oldMemRef, bOuter);
 
   // Create and place the alloc right before the 'affine.for' operation.
-  Value newMemRef =
-      bOuter.create<AllocOp>(forOp.getLoc(), newMemRefType, allocOperands);
+  Value newMemRef = bOuter.create<memref::AllocOp>(
+      forOp.getLoc(), newMemRefType, allocOperands);
 
   // Create 'iv mod 2' value to index the leading dimension.
   auto d0 = bInner.getAffineDimExpr(0);
   int64_t step = forOp.getStep();
   auto modTwoMap =
       AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, d0.floorDiv(step) % 2);
   auto ivModTwoOp = bInner.create<AffineApplyOp>(forOp.getLoc(), modTwoMap,
                                                  forOp.getInductionVar());
if (failed(replaceAllMemRefUsesWith(
           /*domInstFilter=*/&*forOp.getBody()->begin()))) {
     LLVM_DEBUG(
         forOp.emitError("memref replacement for double buffering failed"));
     ivModTwoOp.erase();
     return false;
   }
   // Insert the dealloc op right after the for loop.
   bOuter.setInsertionPointAfter(forOp);
-  bOuter.create<DeallocOp>(forOp.getLoc(), newMemRef);
+  bOuter.create<memref::DeallocOp>(forOp.getLoc(), newMemRef);
 
   return true;
 }
 
 /// Returns success if the IR is in a valid state.
 void PipelineDataTransfer::runOnFunction() {
   // Do a post order walk so that inner loop DMAs are processed first. This is
   // necessary since 'affine.for' operations nested within would otherwise
for (auto &op : *forOp.getBody()) {
     if (it != outgoingDmaOps.end())
       continue;
 
     // We only double buffer if the buffer is not live out of loop.
     auto memref = dmaStartOp.getOperand(dmaStartOp.getFasterMemPos());
     bool escapingUses = false;
     for (auto *user : memref.getUsers()) {
       // We can double buffer regardless of dealloc's outside the loop.
-      if (isa<DeallocOp>(user))
+      if (isa<memref::DeallocOp>(user))
         continue;
       if (!forOp.getBody()->findAncestorOpInBlock(*user)) {
         LLVM_DEBUG(llvm::dbgs()
                        << "can't pipeline: buffer is live out of loop\n";);
         escapingUses = true;
         break;
       }
     }
for (auto &pair : startWaitPairs) {
     // operation could have been used on it if it was dynamically shaped in
     // order to create the double buffer above.)
     // '-canonicalize' does this in a more general way, but we'll anyway do the
     // simple/common case so that the output / test cases looks clear.
     if (auto *allocOp = oldMemRef.getDefiningOp()) {
       if (oldMemRef.use_empty()) {
         allocOp->erase();
       } else if (oldMemRef.hasOneUse()) {
-        if (auto dealloc = dyn_cast<DeallocOp>(*oldMemRef.user_begin())) {
+        if (auto dealloc =
+                dyn_cast<memref::DeallocOp>(*oldMemRef.user_begin())) {
           dealloc.erase();
           allocOp->erase();
         }
       }
     }
   }
 
   // Double the buffers for tag memrefs.
   for (auto &pair : startWaitPairs) {
     auto *dmaFinishOp = pair.second;
     Value oldTagMemRef = dmaFinishOp->getOperand(getTagMemRefPos(*dmaFinishOp));
     if (!doubleBuffer(oldTagMemRef, forOp)) {
       LLVM_DEBUG(llvm::dbgs() << "tag double buffering failed\n";);
       return;
     }
     // If the old tag has no uses or a single dealloc use, remove it.
     // (canonicalization handles more complex cases).
     if (auto *tagAllocOp = oldTagMemRef.getDefiningOp()) {
       if (oldTagMemRef.use_empty()) {
         tagAllocOp->erase();
       } else if (oldTagMemRef.hasOneUse()) {
-        if (auto dealloc = dyn_cast<DeallocOp>(*oldTagMemRef.user_begin())) {
+        if (auto dealloc =
+                dyn_cast<memref::DeallocOp>(*oldTagMemRef.user_begin())) {
           dealloc.erase();
           tagAllocOp->erase();
         }
       }
     }
   }
 
   // Double buffering would have invalidated all the old DMA start/wait insts.

mlir/lib/Transforms/Utils/LoopUtils.cpp

 #include "mlir/Transforms/LoopUtils.h"
 
 #include "mlir/Analysis/AffineAnalysis.h"
 #include "mlir/Analysis/LoopAnalysis.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
static LogicalResult generateCopy(
   if (!existingBuf) {
     AffineMap fastBufferLayout = b.getMultiDimIdentityMap(rank);
     auto fastMemRefType =
         MemRefType::get(fastBufferShape, memRefType.getElementType(),
                         fastBufferLayout, copyOptions.fastMemorySpace);
 
     // Create the fast memory space buffer just before the 'affine.for'
     // operation.
-    fastMemRef = prologue.create<AllocOp>(loc, fastMemRefType).getResult();
+    fastMemRef =
+        prologue.create<memref::AllocOp>(loc, fastMemRefType).getResult();
     // Record it.
     fastBufferMap[memref] = fastMemRef;
     // fastMemRefType is a constant shaped memref.
     *sizeInBytes = getMemRefSizeInBytes(fastMemRefType).getValue();
     LLVM_DEBUG(emitRemarkForBlock(*block)
                << "Creating fast buffer of type " << fastMemRefType
                << " and size " << llvm::divideCeil(*sizeInBytes, 1024)
                << " KiB\n");
if (!copyOptions.generateDma) {
     // mark end of block range being processed if necessary.
     if (region.isWrite() && isCopyOutAtEndOfBlock)
       *nEnd = Block::iterator(copyNest.getOperation());
   } else {
     // DMA generation.
     // Create a tag (single element 1-d memref) for the DMA.
     auto tagMemRefType = MemRefType::get({1}, top.getIntegerType(32), {},
                                          copyOptions.tagMemorySpace);
-    auto tagMemRef = prologue.create<AllocOp>(loc, tagMemRefType);
+    auto tagMemRef = prologue.create<memref::AllocOp>(loc, tagMemRefType);
 
     SmallVector<Value, 4> tagIndices({zeroIndex});
     auto tagAffineMap = b.getMultiDimIdentityMap(tagIndices.size());
     fullyComposeAffineMapAndOperands(&tagAffineMap, &tagIndices);
     if (!region.isWrite()) {
       // DMA non-blocking read from original buffer to fast buffer.
       b.create<AffineDmaStartOp>(loc, memref, memAffineMap, memIndices,
                                  fastMemRef, bufAffineMap, bufIndices,
if (!region.isWrite()) {
         *nEnd = Block::iterator(op.getOperation());
     }
 
     // Matching DMA wait to block on completion; tag always has a 0 index.
     b.create<AffineDmaWaitOp>(loc, tagMemRef, tagAffineMap, zeroIndex,
                               numElementsSSA);
 
     // Generate dealloc for the tag.
-    auto tagDeallocOp = epilogue.create<DeallocOp>(loc, tagMemRef);
+    auto tagDeallocOp = epilogue.create<memref::DeallocOp>(loc, tagMemRef);
     if (*nEnd == end && isCopyOutAtEndOfBlock)
       // Since new ops are being appended (for outgoing DMAs), adjust the end to
       // mark end of range of the original.
       *nEnd = Block::iterator(tagDeallocOp.getOperation());
   }
 
   // Generate dealloc for the buffer.
   if (!existingBuf) {
-    auto bufDeallocOp = epilogue.create<DeallocOp>(loc, fastMemRef);
+    auto bufDeallocOp = epilogue.create<memref::DeallocOp>(loc, fastMemRef);
     // When generating pointwise copies, `nEnd' has to be set to deallocOp on
     // the fast buffer (since it marks the new end insertion point).
     if (!copyOptions.generateDma && *nEnd == end && isCopyOutAtEndOfBlock)
       *nEnd = Block::iterator(bufDeallocOp.getOperation());
   }
 
   // Replace all uses of the old memref with the faster one while remapping
   // access indices (subtracting out lower bound offsets for each dimension).

mlir/lib/Transforms/Utils/Utils.cpp

if (domInstFilter && !domInfo->dominates(domInstFilter, op))
       continue;
 
     // Skip this use if it's not post-dominated by postDomInstFilter.
     if (postDomInstFilter && !postDomInfo->postDominates(postDomInstFilter, op))
       continue;
 
     // Skip dealloc's - no replacement is necessary, and a memref replacement
     // at other uses doesn't hurt these dealloc's.
-    if (isa<DeallocOp>(op) && !replaceInDeallocOp)
+    if (isa<memref::DeallocOp>(op) && !replaceInDeallocOp)
       continue;
 
     // Check if the memref was used in a non-dereferencing context. It is fine
     // for the memref to be used in a non-dereferencing way outside of the
     // region where this replacement is happening.
     if (!isa<AffineMapAccessInterface>(*op)) {
       if (!allowNonDereferencingOps)
         return failure();
for (unsigned i = 0, e = newOperands.size(); i < e; i++) {
     }
   }
   for (unsigned idx = 0, e = newOperands.size(); idx < e; idx++) {
     opInst->setOperand(idx, newOperands[idx]);
   }
 }
 
 // TODO: Currently works for static memrefs with a single layout map.
-LogicalResult mlir::normalizeMemRef(AllocOp allocOp) {
+LogicalResult mlir::normalizeMemRef(memref::AllocOp allocOp) {
   MemRefType memrefType = allocOp.getType();
   OpBuilder b(allocOp);
 
   // Fetch a new memref type after normalizing the old memref to have an
   // identity map layout.
   MemRefType newMemRefType =
       normalizeMemRefType(memrefType, b, allocOp.symbolOperands().size());
   if (newMemRefType == memrefType)
     // Either memrefType already had an identity map or the map couldn't be
     // transformed to an identity map.
     return failure();
 
   Value oldMemRef = allocOp.getResult();
 
   SmallVector<Value, 4> symbolOperands(allocOp.symbolOperands());
-  AllocOp newAlloc = b.create<AllocOp>(allocOp.getLoc(), newMemRefType,
-                                       allocOp.alignmentAttr());
+  memref::AllocOp newAlloc = b.create<memref::AllocOp>(
+      allocOp.getLoc(), newMemRefType, allocOp.alignmentAttr());
   AffineMap layoutMap = memrefType.getAffineMaps().front();
   // Replace all uses of the old memref.
   if (failed(replaceAllMemRefUsesWith(oldMemRef, /*newMemRef=*/newAlloc,
                                       /*extraIndices=*/{},
                                       /*indexRemap=*/layoutMap,
                                       /*extraOperands=*/{},
                                       /*symbolOperands=*/symbolOperands,
                                       /*domInstFilter=*/nullptr,
                                       /*postDomInstFilter=*/nullptr,
                                       /*allowDereferencingOps=*/true))) {
     // If it failed (due to escapes for example), bail out.
     newAlloc.erase();
     return failure();
   }
   // Replace any uses of the original alloc op and erase it. All remaining uses
   // have to be dealloc's; RAMUW above would've failed otherwise.
-  assert(llvm::all_of(oldMemRef.getUsers(),
-                      [](Operation *op) { return isa<DeallocOp>(op); }));
+  assert(llvm::all_of(oldMemRef.getUsers(), [](Operation *op) {
+    return isa<memref::DeallocOp>(op);
+  }));
   oldMemRef.replaceAllUsesWith(newAlloc);
   allocOp.erase();
   return success();
 }
 
 MemRefType mlir::normalizeMemRefType(MemRefType memrefType, OpBuilder b,
                                      unsigned numSymbolicOperands) {
   unsigned rank = memrefType.getRank();

mlir/test/Analysis/test-alias-analysis.mlir

 // NoAlias with a proper escape analysis.
 // CHECK-DAG: alloc_1#0 <-> alloc_2#0: NoAlias
 // CHECK-DAG: alloc_1#0 <-> func.region0#0: MayAlias
 // CHECK-DAG: alloc_1#0 <-> func.region0#1: MayAlias
 
 // CHECK-DAG: alloc_2#0 <-> func.region0#0: MayAlias
 // CHECK-DAG: alloc_2#0 <-> func.region0#1: MayAlias
 func @simple(%arg: memref<2xf32>, %arg1: memref<2xf32>) attributes {test.ptr = "func"} {
-  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
-  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
-  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
-  %3 = alloc() {test.ptr = "alloc_2"} : memref<8x64xf32>
+  %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %3 = memref.alloc() {test.ptr = "alloc_2"} : memref<8x64xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: Testing : "control_flow"
 // CHECK-DAG: alloca_1#0 <-> func.region0.block1#0: MustAlias
 // CHECK-DAG: alloca_1#0 <-> func.region0.block2#0: MustAlias
 
 // CHECK-DAG: alloca_2#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: alloca_2#0 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: alloc_1#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: alloc_1#0 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: func.region0#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: func.region0#0 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: func.region0#1 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MustAlias
 func @control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
-  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
-  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
-  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%0 : memref<8x64xf32>)
 
 ^bb1(%arg1: memref<8x64xf32>):
   br ^bb2(%arg1 : memref<8x64xf32>)
 
 ^bb2(%arg2: memref<8x64xf32>):
   return

 // CHECK-DAG: func.region0#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: func.region0#0 <-> func.region0.block2#0: MayAlias
 
 // CHECK-DAG: func.region0#1 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: func.region0#1 <-> func.region0.block2#0: MayAlias
 
 // CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MayAlias
 func @control_flow_merge(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
-  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
-  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
-  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%2 : memref<8x64xf32>)
 
 ^bb1(%arg1: memref<8x64xf32>):
   br ^bb2(%arg1 : memref<8x64xf32>)
 
 ^bb2(%arg2: memref<8x64xf32>):
   return

 
 // CHECK-DAG: if_alloca_merge#0 <-> if_alloc#0: NoAlias
 // CHECK-DAG: if_alloca_merge#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: if_alloca_merge#0 <-> func.region0#1: NoAlias
 
 // CHECK-DAG: if_alloc#0 <-> func.region0#0: MayAlias
 // CHECK-DAG: if_alloc#0 <-> func.region0#1: MayAlias
 func @region_control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
-  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
-  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
-  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   %3 = scf.if %cond -> (memref<8x64xf32>) {
     scf.yield %0 : memref<8x64xf32>
   } else {
     scf.yield %0 : memref<8x64xf32>
   } {test.ptr = "if_alloca"}
 
   %4 = scf.if %cond -> (memref<8x64xf32>) {

 // CHECK-DAG: for_alloca.region0#0 <-> func.region0#3: MayAlias
 
 // CHECK-DAG: for_alloca.region0#1 <-> func.region0#0: NoAlias
 // CHECK-DAG: for_alloca.region0#1 <-> func.region0#1: NoAlias
 // CHECK-DAG: for_alloca.region0#1 <-> func.region0#2: NoAlias
 // CHECK-DAG: for_alloca.region0#1 <-> func.region0#3: NoAlias
 func @region_loop_control_flow(%arg: memref<2xf32>, %loopI0 : index,
                                %loopI1 : index, %loopI2 : index) attributes {test.ptr = "func"} {
-  %0 = alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
-  %1 = alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
-  %2 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
+  %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
+  %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   %result = scf.for %i0 = %loopI0 to %loopI1 step %loopI2 iter_args(%si = %0) -> (memref<8x64xf32>) {
     scf.yield %si : memref<8x64xf32>
   } {test.ptr = "for_alloca"}
   return
 }
 
 // -----
 
 // CHECK-LABEL: Testing : "view_like"
 // CHECK-DAG: alloc_1#0 <-> view#0: NoAlias
 
 // CHECK-DAG: alloca_1#0 <-> view#0: MustAlias
 
 // CHECK-DAG: view#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: view#0 <-> func.region0#1: NoAlias
 func @view_like(%arg: memref<2xf32>, %size: index) attributes {test.ptr = "func"} {
-  %1 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %1 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   %c0 = constant 0 : index
-  %2 = alloca (%size) {test.ptr = "alloca_1"} : memref<?xi8>
-  %3 = view %2[%c0][] {test.ptr = "view"} : memref<?xi8> to memref<8x64xf32>
+  %2 = memref.alloca (%size) {test.ptr = "alloca_1"} : memref<?xi8>
+  %3 = memref.view %2[%c0][] {test.ptr = "view"} : memref<?xi8> to memref<8x64xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: Testing : "constants"
 // CHECK-DAG: alloc_1#0 <-> constant_1#0: NoAlias
 // CHECK-DAG: alloc_1#0 <-> constant_2#0: NoAlias
 // CHECK-DAG: alloc_1#0 <-> constant_3#0: NoAlias
 
 // CHECK-DAG: constant_1#0 <-> constant_2#0: MayAlias
 // CHECK-DAG: constant_1#0 <-> constant_3#0: MayAlias
 // CHECK-DAG: constant_1#0 <-> func.region0#0: MayAlias
 
 // CHECK-DAG: constant_2#0 <-> constant_3#0: MayAlias
 // CHECK-DAG: constant_2#0 <-> func.region0#0: MayAlias
 
 // CHECK-DAG: constant_3#0 <-> func.region0#0: MayAlias
 func @constants(%arg: memref<2xf32>) attributes {test.ptr = "func"} {
-  %1 = alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
+  %1 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   %c0 = constant {test.ptr = "constant_1"} 0 : index
   %c0_2 = constant {test.ptr = "constant_2"} 0 : index
   %c1 = constant {test.ptr = "constant_3"} 1 : index
 
   return
 }

mlir/test/Analysis/test-liveness.mlir

func @nested_region(
   %0 = addi %arg3, %arg4 : i32
   %1 = addi %arg4, %arg5 : i32
   scf.for %arg6 = %arg0 to %arg1 step %arg2 {
     // CHECK: Block: 1
     // CHECK-NEXT: LiveIn: arg5@0 arg6@0 val_7
     // CHECK-NEXT: LiveOut:{{ *$}}
     %2 = addi %0, %arg5 : i32
     %3 = addi %2, %0 : i32
-    store %3, %buffer[] : memref<i32>
+    memref.store %3, %buffer[] : memref<i32>
   }
   return %1 : i32
 }
 
 // -----
 
 // CHECK-LABEL: Testing : nested_region2
 
scf.for %arg6 = %arg0 to %arg1 step %arg2 {
     // CHECK-NEXT: val_10
     // CHECK-NEXT:    %2 = addi
     // CHECK-NEXT:    scf.for
     // CHECK:         // %3 = addi
     // CHECK: EndLiveness
     %2 = addi %0, %arg5 : i32
     scf.for %arg7 = %arg0 to %arg1 step %arg2 {
       %3 = addi %2, %0 : i32
-      store %3, %buffer[] : memref<i32>
+      memref.store %3, %buffer[] : memref<i32>
     }
   }
   return %1 : i32
 }
 
 // -----
 
 // CHECK-LABEL: Testing : nested_region3
func @nested_region3(
   %buffer : memref<i32>) -> i32 {
   %0 = addi %arg3, %arg4 : i32
   %1 = addi %arg4, %arg5 : i32
   scf.for %arg6 = %arg0 to %arg1 step %arg2 {
     // CHECK: Block: 1
     // CHECK-NEXT: LiveIn: arg5@0 arg6@0 val_7
     // CHECK-NEXT: LiveOut:{{ *$}}
     %2 = addi %0, %arg5 : i32
-    store %2, %buffer[] : memref<i32>
+    memref.store %2, %buffer[] : memref<i32>
   }
   br ^exit
 
 ^exit:
   // CHECK: Block: 2
   // CHECK-NEXT: LiveIn: arg0@0 arg1@0 arg2@0 arg6@0 val_7 val_8
   // CHECK-NEXT: LiveOut:{{ *$}}
   scf.for %arg7 = %arg0 to %arg1 step %arg2 {
     // CHECK: Block: 3
     // CHECK-NEXT: LiveIn: arg6@0 val_7 val_8
     // CHECK-NEXT: LiveOut:{{ *$}}
     %2 = addi %0, %1 : i32
-    store %2, %buffer[] : memref<i32>
+    memref.store %2, %buffer[] : memref<i32>
   }
   return %1 : i32
 }

mlir/test/CAPI/ir.c

void populateLoopBody(MlirContext ctx, MlirBlock loopBody,
   MlirValue addOperands[] = {mlirOperationGetResult(loadLHS, 0),
                              mlirOperationGetResult(loadRHS, 0)};
   mlirOperationStateAddOperands(&addState, 2, addOperands);
   mlirOperationStateAddResults(&addState, 1, &f32Type);
   MlirOperation add = mlirOperationCreate(&addState);
   mlirBlockAppendOwnedOperation(loopBody, add);
 
   MlirOperationState storeState = mlirOperationStateGet(
-      mlirStringRefCreateFromCString("std.store"), location);
+      mlirStringRefCreateFromCString("memref.store"), location);
   MlirValue storeOperands[] = {mlirOperationGetResult(add, 0), funcArg0, iv};
   mlirOperationStateAddOperands(&storeState, 3, storeOperands);
   MlirOperation store = mlirOperationCreate(&storeState);
   mlirBlockAppendOwnedOperation(loopBody, store);
 
   MlirOperationState yieldState = mlirOperationStateGet(
       mlirStringRefCreateFromCString("scf.yield"), location);
   MlirOperation yield = mlirOperationCreate(&yieldState);
MlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
   // CHECK:   func @add(%[[ARG0:.*]]: memref<?xf32>, %[[ARG1:.*]]: memref<?xf32>) {
   // CHECK:     %[[C0:.*]] = constant 0 : index
   // CHECK:     %[[DIM:.*]] = dim %[[ARG0]], %[[C0]] : memref<?xf32>
   // CHECK:     %[[C1:.*]] = constant 1 : index
   // CHECK:     scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
   // CHECK:       %[[LHS:.*]] = load %[[ARG0]][%[[I]]] : memref<?xf32>
   // CHECK:       %[[RHS:.*]] = load %[[ARG1]][%[[I]]] : memref<?xf32>
   // CHECK:       %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
-  // CHECK:       store %[[SUM]], %[[ARG0]][%[[I]]] : memref<?xf32>
+  // CHECK:       memref.store %[[SUM]], %[[ARG0]][%[[I]]] : memref<?xf32>
   // CHECK:     }
   // CHECK:     return
   // CHECK:   }
   // CHECK: }
   // clang-format on
 
   return moduleOp;
 }
static void printFirstOfEach(MlirContext ctx, MlirOperation operation) {
   // clang-format off
   // CHECK:   %[[C0:.*]] = constant 0 : index
   // CHECK:   %[[DIM:.*]] = dim %{{.*}}, %[[C0]] : memref<?xf32>
   // CHECK:   %[[C1:.*]] = constant 1 : index
   // CHECK:   scf.for %[[I:.*]] = %[[C0]] to %[[DIM]] step %[[C1]] {
   // CHECK:     %[[LHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
   // CHECK:     %[[RHS:.*]] = load %{{.*}}[%[[I]]] : memref<?xf32>
   // CHECK:     %[[SUM:.*]] = addf %[[LHS]], %[[RHS]] : f32
-  // CHECK:     store %[[SUM]], %{{.*}}[%[[I]]] : memref<?xf32>
+  // CHECK:     memref.store %[[SUM]], %{{.*}}[%[[I]]] : memref<?xf32>
   // CHECK:   }
   // CHECK: return
   // CHECK: First operation: {{.*}} = constant 0 : index
   // clang-format on
 
   // Get the operation name and print it.
   MlirIdentifier ident = mlirOperationGetName(operation);
   MlirStringRef identStr = mlirIdentifierStr(ident);

mlir/test/Conversion/AffineToStandard/lower-affine-to-vector.mlir

 // RUN: mlir-opt -lower-affine --split-input-file %s | FileCheck %s
 
-
 // CHECK-LABEL: func @affine_vector_load
 func @affine_vector_load(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   affine.for %i0 = 0 to 16 {
     %1 = affine.vector_load %0[%i0 + symbol(%arg0) + 7] : memref<100xf32>, vector<8xf32>
   }
-// CHECK:       %[[buf:.*]] = alloc
+// CHECK:       %[[buf:.*]] = memref.alloc
 // CHECK:       %[[a:.*]] = addi %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:  %[[c7:.*]] = constant 7 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %[[a]], %[[c7]] : index
 // CHECK-NEXT:  vector.load %[[buf]][%[[b]]] : memref<100xf32>, vector<8xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @affine_vector_store
 func @affine_vector_store(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %1 = constant dense<11.0> : vector<4xf32>
   affine.for %i0 = 0 to 16 {
     affine.vector_store %1, %0[%i0 - symbol(%arg0) + 7] : memref<100xf32>, vector<4xf32>
 }
-// CHECK:       %[[buf:.*]] = alloc
+// CHECK:       %[[buf:.*]] = memref.alloc
 // CHECK:       %[[val:.*]] = constant dense
 // CHECK:       %[[c_1:.*]] = constant -1 : index
 // CHECK-NEXT:  %[[a:.*]] = muli %arg0, %[[c_1]] : index
 // CHECK-NEXT:  %[[b:.*]] = addi %{{.*}}, %[[a]] : index
 // CHECK-NEXT:  %[[c7:.*]] = constant 7 : index
 // CHECK-NEXT:  %[[c:.*]] = addi %[[b]], %[[c7]] : index
 // CHECK-NEXT:  vector.store %[[val]], %[[buf]][%[[c]]] : memref<100xf32>, vector<4xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @vector_load_2d
 func @vector_load_2d() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 16 step 2{
     affine.for %i1 = 0 to 16 step 8 {
       %1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
-// CHECK:      %[[buf:.*]] = alloc
+// CHECK:      %[[buf:.*]] = memref.alloc
 // CHECK:      scf.for %[[i0:.*]] =
 // CHECK:        scf.for %[[i1:.*]] =
 // CHECK-NEXT:     vector.load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @vector_store_2d
 func @vector_store_2d() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %1 = constant dense<11.0> : vector<2x8xf32>
   affine.for %i0 = 0 to 16 step 2{
     affine.for %i1 = 0 to 16 step 8 {
       affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
-// CHECK:      %[[buf:.*]] = alloc
+// CHECK:      %[[buf:.*]] = memref.alloc
 // CHECK:      %[[val:.*]] = constant dense
 // CHECK:      scf.for %[[i0:.*]] =
 // CHECK:        scf.for %[[i1:.*]] =
 // CHECK-NEXT:     vector.store %[[val]], %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
     }
   }
   return
 }

mlir/test/Conversion/AffineToStandard/lower-affine.mlir

 // CHECK-NEXT:  %[[v6:.*]] = addi %[[v4]], %[[c1]] : index
 // CHECK-NEXT:  %[[v7:.*]] = select %[[v0]], %[[v5]], %[[v6]] : index
   %0 = affine.apply #mapceildiv (%arg0)
   return %0 : index
 }
 
 // CHECK-LABEL: func @affine_load
 func @affine_load(%arg0 : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     %1 = affine.load %0[%i0 + symbol(%arg0) + 7] : memref<10xf32>
   }
 // CHECK:       %[[a:.*]] = addi %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:  %[[c7:.*]] = constant 7 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %[[a]], %[[c7]] : index
 // CHECK-NEXT:  %{{.*}} = load %[[v0:.*]][%[[b]]] : memref<10xf32>
   return
 }
 
 // CHECK-LABEL: func @affine_store
 func @affine_store(%arg0 : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %1 = constant 11.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.store %1, %0[%i0 - symbol(%arg0) + 7] : memref<10xf32>
   }
 // CHECK:       %c-1 = constant -1 : index
 // CHECK-NEXT:  %[[a:.*]] = muli %arg0, %c-1 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %{{.*}}, %[[a]] : index
 // CHECK-NEXT:  %c7 = constant 7 : index
 // CHECK-NEXT:  %[[c:.*]] = addi %[[b]], %c7 : index
 // CHECK-NEXT:  store %cst, %0[%[[c]]] : memref<10xf32>
   return
 }
 
 // CHECK-LABEL: func @affine_load_store_zero_dim
 func @affine_load_store_zero_dim(%arg0 : memref<i32>, %arg1 : memref<i32>) {
   %0 = affine.load %arg0[] : memref<i32>
   affine.store %0, %arg1[] : memref<i32>
 // CHECK: %[[x:.*]] = load %arg0[] : memref<i32>
 // CHECK: store %[[x]], %arg1[] : memref<i32>
   return
 }
 
 // CHECK-LABEL: func @affine_prefetch
 func @affine_prefetch(%arg0 : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.prefetch %0[%i0 + symbol(%arg0) + 7], read, locality<3>, data : memref<10xf32>
   }
 // CHECK:       %[[a:.*]] = addi %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:  %[[c7:.*]] = constant 7 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %[[a]], %[[c7]] : index
-// CHECK-NEXT:  prefetch %[[v0:.*]][%[[b]]], read, locality<3>, data : memref<10xf32>
+// CHECK-NEXT:  memref.prefetch %[[v0:.*]][%[[b]]], read, locality<3>, data : memref<10xf32>
   return
 }
 
 // CHECK-LABEL: func @affine_dma_start
 func @affine_dma_start(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
-  %1 = alloc() : memref<100xf32, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100xf32>
+  %1 = memref.alloc() : memref<100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.dma_start %0[%i0 + 7], %1[%arg0 + 11], %2[%c0], %c64
         : memref<100xf32>, memref<100xf32, 2>, memref<1xi32>
   }
 // CHECK:       %c7 = constant 7 : index
 // CHECK-NEXT:  %[[a:.*]] = addi %{{.*}}, %c7 : index
 // CHECK-NEXT:  %c11 = constant 11 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %arg0, %c11 : index
 // CHECK-NEXT:  dma_start %0[%[[a]]], %1[%[[b]]], %c64, %2[%c0] : memref<100xf32>, memref<100xf32, 2>, memref<1xi32>
   return
 }
 
 // CHECK-LABEL: func @affine_dma_wait
 func @affine_dma_wait(%arg0 : index) {
-  %2 = alloc() : memref<1xi32>
+  %2 = memref.alloc() : memref<1xi32>
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.dma_wait %2[%i0 + %arg0 + 17], %c64 : memref<1xi32>
   }
 // CHECK:       %[[a:.*]] = addi %{{.*}}, %arg0 : index
 // CHECK-NEXT:  %c17 = constant 17 : index
 // CHECK-NEXT:  %[[b:.*]] = addi %[[a]], %c17 : index
 // CHECK-NEXT:  dma_wait %0[%[[b]]], %c64 : memref<1xi32>

 // CHECK:             %[[A3:.*]] = load %[[ARG1]][%[[arg6]], %[[arg8]]] : memref<100x100xf32>
 // CHECK:             %[[A4:.*]] = load %[[ARG2]][%[[arg8]], %[[arg7]]] : memref<100x100xf32>
 // CHECK:             mulf %[[A3]], %[[A4]] : f32
 // CHECK:             scf.yield
 
 /////////////////////////////////////////////////////////////////////
 
 func @affine_parallel_simple(%arg0: memref<3x3xf32>, %arg1: memref<3x3xf32>) -> (memref<3x3xf32>) {
-  %O = alloc() : memref<3x3xf32>
+  %O = memref.alloc() : memref<3x3xf32>
   affine.parallel (%kx, %ky) = (0, 0) to (2, 2) {
       %1 = affine.load %arg0[%kx, %ky] : memref<3x3xf32>
       %2 = affine.load %arg1[%kx, %ky] : memref<3x3xf32>
       %3 = mulf %1, %2 : f32
       affine.store %3, %O[%kx, %ky] : memref<3x3xf32>
   }
   return %O : memref<3x3xf32>
 }

mlir/test/Conversion/AsyncToLLVM/convert-to-llvm.mlir

 
 // -----
 
 // CHECK-LABEL: execute_no_async_args
 func @execute_no_async_args(%arg0: f32, %arg1: memref<1xf32>) {
   // CHECK: %[[TOKEN:.*]] = call @async_execute_fn(%arg0, %arg1)
   %token = async.execute {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
   // CHECK-NEXT: return
   async.await %token : !async.token
   return
 }
 

 // Decide the next block based on the code returned from suspend.
 // CHECK: %[[SEXT:.*]] = llvm.sext %[[SUSPENDED]] : i8 to i32
 // CHECK: llvm.switch %[[SEXT]], ^[[SUSPEND:[b0-9]+]]
 // CHECK-NEXT: 0: ^[[RESUME:[b0-9]+]]
 // CHECK-NEXT: 1: ^[[CLEANUP:[b0-9]+]]
 
 // Resume coroutine after suspension.
 // CHECK: ^[[RESUME]]:
-// CHECK: store %arg0, %arg1[%c0] : memref<1xf32>
+// CHECK: memref.store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET]])
 
 // Delete coroutine.
 // CHECK: ^[[CLEANUP]]:
 // CHECK: %[[MEM:.*]] = llvm.intr.coro.free
 // CHECK: llvm.call @free(%[[MEM]])
 
 // Suspend coroutine, and also a return statement for ramp function.
 // CHECK: ^[[SUSPEND]]:
 // CHECK: llvm.intr.coro.end
 // CHECK: return %[[RET]]
 
 // -----
 
 // CHECK-LABEL: nested_async_execute
 func @nested_async_execute(%arg0: f32, %arg1: f32, %arg2: memref<1xf32>) {
   // CHECK: %[[TOKEN:.*]] = call @async_execute_fn_0(%arg0, %arg2, %arg1)
   %token0 = async.execute {
     %c0 = constant 0 : index
 
     %token1 = async.execute {
       %c1 = constant 1: index
-      store %arg0, %arg2[%c0] : memref<1xf32>
+      memref.store %arg0, %arg2[%c0] : memref<1xf32>
       async.yield
     }
     async.await %token1 : !async.token
 
-    store %arg1, %arg2[%c0] : memref<1xf32>
+    memref.store %arg1, %arg2[%c0] : memref<1xf32>
     async.yield
   }
   // CHECK: call @mlirAsyncRuntimeAwaitToken(%[[TOKEN]])
   // CHECK-NEXT: return
   async.await %token0 : !async.token
   return
 }
 
 // Function outlined from the inner async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>, %arg2: index)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_0:.*]] = llvm.intr.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.intr.coro.suspend
-// CHECK: store %arg0, %arg1[%arg2] : memref<1xf32>
+// CHECK: memref.store %arg0, %arg1[%arg2] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the outer async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn_0(%arg0: f32, %arg1: memref<1xf32>, %arg2: f32)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_1:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of inner execute op.
 // CHECK: %[[TOKEN_1:.*]] = call @async_execute_fn
 // CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitTokenAndExecute(%[[TOKEN_1]], %[[HDL_1]]
 // CHECK: llvm.intr.coro.suspend
 
 // Emplace result token after second resumption.
-// CHECK: store %arg2, %arg1[%c0] : memref<1xf32>
+// CHECK: memref.store %arg2, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_1]])
 
 // -----
 
 // CHECK-LABEL: async_execute_token_dependency
 func @async_execute_token_dependency(%arg0: f32, %arg1: memref<1xf32>) {
   // CHECK: %0 = call @async_execute_fn(%arg0, %arg1)
   %token = async.execute {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   // CHECK: %1 = call @async_execute_fn_0(%0, %arg0, %arg1)
   %token_0 = async.execute [%token] {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   return
 }
 
 // Function outlined from the first async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn(%arg0: f32, %arg1: memref<1xf32>)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_0:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_0:.*]] = llvm.intr.coro.begin
 // CHECK: call @mlirAsyncRuntimeExecute
 // CHECK: llvm.intr.coro.suspend
-// CHECK: store %arg0, %arg1[%c0] : memref<1xf32>
+// CHECK: memref.store %arg0, %arg1[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_0]])
 
 // Function outlined from the second async.execute operation with dependency.
 // CHECK-LABEL: func private @async_execute_fn_0(%arg0: !llvm.ptr<i8>, %arg1: f32, %arg2: memref<1xf32>)
 // CHECK-SAME: -> !llvm.ptr<i8>
 // CHECK: %[[RET_1:.*]] = call @mlirAsyncRuntimeCreateToken()
 // CHECK: %[[HDL_1:.*]] = llvm.intr.coro.begin
 
 // Suspend coroutine in the beginning.
 // CHECK: call @mlirAsyncRuntimeExecute(%[[HDL_1]],
 // CHECK: llvm.intr.coro.suspend
 
 // Suspend coroutine second time waiting for the completion of token dependency.
 // CHECK: llvm.intr.coro.save
 // CHECK: call @mlirAsyncRuntimeAwaitTokenAndExecute(%arg0, %[[HDL_1]],
 // CHECK: llvm.intr.coro.suspend
 
 // Emplace result token after second resumption.
-// CHECK: store %arg1, %arg2[%c0] : memref<1xf32>
+// CHECK: memref.store %arg1, %arg2[%c0] : memref<1xf32>
 // CHECK: call @mlirAsyncRuntimeEmplaceToken(%[[RET_1]])
 
 // -----
 
 // CHECK-LABEL: async_group_await_all
 func @async_group_await_all(%arg0: f32, %arg1: memref<1xf32>) {
   // CHECK: %0 = call @mlirAsyncRuntimeCreateGroup()
   %0 = async.create_group

mlir/test/Conversion/GPUCommon/memory-attrbution.mlir

gpu.func @private(%arg0: f32) private(%arg1: memref<4xf32, 5>) {
     // NVVM: llvm.extractvalue %[[descr6:.*]]
     // NVVM: llvm.getelementptr
     // NVVM: llvm.store
 
     // ROCDL: llvm.extractvalue %[[descr6:.*]]
     // ROCDL: llvm.getelementptr
     // ROCDL: llvm.store
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<4xf32, 5>
+    memref.store %arg0, %arg1[%c0] : memref<4xf32, 5>
 
     "terminator"() : () -> ()
   }
 }
 
 // -----
 
 gpu.module @kernel {
gpu.func @workgroup(%arg0: f32) workgroup(%arg1: memref<4xf32, 3>) {
     // NVVM: llvm.extractvalue %[[descr6:.*]]
     // NVVM: llvm.getelementptr
     // NVVM: llvm.store
 
     // ROCDL: llvm.extractvalue %[[descr6:.*]]
     // ROCDL: llvm.getelementptr
     // ROCDL: llvm.store
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<4xf32, 3>
+    memref.store %arg0, %arg1[%c0] : memref<4xf32, 3>
 
     "terminator"() : () -> ()
   }
 }
 
 // -----
 
 gpu.module @kernel {
gpu.func @workgroup3d(%arg0: f32) workgroup(%arg1: memref<4x2x6xf32, 3>) {
     // ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
     // ROCDL: %[[descr8:.*]] = llvm.insertvalue %[[c6]], %[[descr7]][4, 1]
     // ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
     // ROCDL: %[[descr9:.*]] = llvm.insertvalue %[[c6]], %[[descr8]][3, 2]
     // ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
     // ROCDL: %[[descr10:.*]] = llvm.insertvalue %[[c1]], %[[descr9]][4, 2]
 
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0,%c0,%c0] : memref<4x2x6xf32, 3>
+    memref.store %arg0, %arg1[%c0,%c0,%c0] : memref<4x2x6xf32, 3>
     "terminator"() : () -> ()
   }
 }
 
 // -----
 
 gpu.module @kernel {
   // Check that several buffers are defined.
gpu.func @multiple(%arg0: f32)
     // NVVM: llvm.alloca %[[c4]] x f32 : (i64) -> !llvm.ptr<f32>
 
     // ROCDL: %[[c3:.*]] = llvm.mlir.constant(3 : i64)
     // ROCDL: llvm.alloca %[[c3]] x f32 : (i64) -> !llvm.ptr<f32, 5>
     // ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : i64)
     // ROCDL: llvm.alloca %[[c4]] x f32 : (i64) -> !llvm.ptr<f32, 5>
 
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32, 3>
-    store %arg0, %arg2[%c0] : memref<2xf32, 3>
-    store %arg0, %arg3[%c0] : memref<3xf32, 5>
-    store %arg0, %arg4[%c0] : memref<4xf32, 5>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32, 3>
+    memref.store %arg0, %arg2[%c0] : memref<2xf32, 3>
+    memref.store %arg0, %arg3[%c0] : memref<3xf32, 5>
+    memref.store %arg0, %arg4[%c0] : memref<4xf32, 5>
     "terminator"() : () -> ()
   }
 }

mlir/test/Conversion/GPUToSPIRV/load-store.mlir

func @load_store(%arg0: memref<12x4xf32>, %arg1: memref<12x4xf32>, %arg2: memref<12x4xf32>) {
     %c1 = constant 1 : index
     %c0_0 = constant 0 : index
     %c4 = constant 4 : index
     %1 = subi %c4, %c0_0 : index
     %c1_1 = constant 1 : index
     %c1_2 = constant 1 : index
     gpu.launch_func @kernels::@load_store_kernel
         blocks in (%0, %c1_2, %c1_2) threads in (%1, %c1_2, %c1_2)
-        args(%arg0 : memref<12x4xf32>, %arg1 : memref<12x4xf32>, %arg2 : memref<12x4xf32>, 
+        args(%arg0 : memref<12x4xf32>, %arg1 : memref<12x4xf32>, %arg2 : memref<12x4xf32>,
              %c0 : index, %c0_0 : index, %c1 : index, %c1_1 : index)
     return
   }
 
   // CHECK-LABEL: spv.module @{{.*}} Logical GLSL450
   gpu.module @kernels {
     // CHECK-DAG: spv.globalVariable @[[NUMWORKGROUPSVAR:.*]] built_in("NumWorkgroups") : !spv.ptr<vector<3xi32>, Input>
     // CHECK-DAG: spv.globalVariable @[[$LOCALINVOCATIONIDVAR:.*]] built_in("LocalInvocationId") : !spv.ptr<vector<3xi32>, Input>
gpu.func @load_store_kernel(%arg0: memref<12x4xf32>, %arg1: memref<12x4xf32>, %arg2: memref<12x4xf32>, %arg3: index, %arg4: index, %arg5: index, %arg6: index) kernel
       %14 = load %arg0[%12, %13] : memref<12x4xf32>
       // CHECK: %[[PTR2:.*]] = spv.AccessChain %[[ARG1]]{{\[}}{{%.*}}, {{%.*}}{{\]}}
       // CHECK-NEXT: %[[VAL2:.*]] = spv.Load "StorageBuffer" %[[PTR2]]
       %15 = load %arg1[%12, %13] : memref<12x4xf32>
       // CHECK: %[[VAL3:.*]] = spv.FAdd %[[VAL1]], %[[VAL2]]
       %16 = addf %14, %15 : f32
       // CHECK: %[[PTR3:.*]] = spv.AccessChain %[[ARG2]]{{\[}}{{%.*}}, {{%.*}}{{\]}}
       // CHECK-NEXT: spv.Store "StorageBuffer" %[[PTR3]], %[[VAL3]]
-      store %16, %arg2[%12, %13] : memref<12x4xf32>
+      memref.store %16, %arg2[%12, %13] : memref<12x4xf32>
       gpu.return
     }
   }
 }

mlir/test/Conversion/GPUToVulkan/lower-gpu-launch-vulkan-launch.mlir

 // RUN: mlir-opt %s -convert-gpu-launch-to-vulkan-launch | FileCheck %s
 
-// CHECK: %[[resource:.*]] = alloc() : memref<12xf32>
+// CHECK: %[[resource:.*]] = memref.alloc() : memref<12xf32>
 // CHECK: %[[index:.*]] = constant 1 : index
 // CHECK: call @vulkanLaunch(%[[index]], %[[index]], %[[index]], %[[resource]]) {spirv_blob = "{{.*}}", spirv_entry_point = "kernel"}
 
 module attributes {gpu.container_module} {
   spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]> {
     spv.globalVariable @kernel_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
     spv.func @kernel() "None" attributes {workgroup_attributions = 0 : i64} {
       %0 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
       %2 = spv.constant 0 : i32
       %3 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
       %4 = spv.AccessChain %0[%2, %2] : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>, i32, i32
       %5 = spv.Load "StorageBuffer" %4 : f32
       spv.Return
     }
     spv.EntryPoint "GLCompute" @kernel
     spv.ExecutionMode @kernel "LocalSize", 1, 1, 1
   }
   gpu.module @kernels {
     gpu.func @kernel(%arg0: memref<12xf32>) kernel {
       gpu.return
     }
   }
   func @foo() {
-    %0 = alloc() : memref<12xf32>
+    %0 = memref.alloc() : memref<12xf32>
     %c1 = constant 1 : index
     gpu.launch_func @kernels::@kernel
         blocks in(%c1, %c1, %c1)
         threads in(%c1, %c1, %c1)
         args(%0 : memref<12xf32>)
     return
   }
 }

mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir

 //   CHECK-DAG:   %[[c4:.*]] = constant 4 : index
 //   CHECK-DAG:   %[[cst:.*]] = constant 0.000000e+00 : f32
 //   CHECK-DAG:   %[[c3:.*]] = constant 3 : index
 //   CHECK-DAG:   %[[c0:.*]] = constant 0 : index
 //   CHECK-DAG:   %[[c1:.*]] = constant 1 : index
 //       CHECK:   %[[v0:.*]] = dim %[[arg1]], %[[c0]] : memref<?xf32>
 //       CHECK:   %[[v1:.*]] = dim %[[arg2]], %[[c0]] : memref<?xf32>
 //       CHECK:   %[[v2:.*]] = dim %[[arg0]], %[[c0]] : memref<?xf32>
-//       CHECK:   %[[v3:.*]] = alloc(%[[c12]]) : memref<?xi8>
-//       CHECK:   %[[v4:.*]] = alloc(%[[c12]]) : memref<?xi8>
-//       CHECK:   %[[v5:.*]] = alloc(%[[c4]]) : memref<?xi8>
-//       CHECK:   %[[v6:.*]] = std.view %[[v3]][%[[c0]]][] : memref<?xi8> to memref<3xf32>
-//       CHECK:   %[[v7:.*]] = std.view %[[v4]][%[[c0]]][] : memref<?xi8> to memref<3xf32>
-//       CHECK:   %[[v8:.*]] = std.view %[[v5]][%[[c0]]][] : memref<?xi8> to memref<1xf32>
+//       CHECK:   %[[v3:.*]] = memref.alloc(%[[c12]]) : memref<?xi8>
+//       CHECK:   %[[v4:.*]] = memref.alloc(%[[c12]]) : memref<?xi8>
+//       CHECK:   %[[v5:.*]] = memref.alloc(%[[c4]]) : memref<?xi8>
+//       CHECK:   %[[v6:.*]] = memref.view %[[v3]][%[[c0]]][] : memref<?xi8> to memref<3xf32>
+//       CHECK:   %[[v7:.*]] = memref.view %[[v4]][%[[c0]]][] : memref<?xi8> to memref<3xf32>
+//       CHECK:   %[[v8:.*]] = memref.view %[[v5]][%[[c0]]][] : memref<?xi8> to memref<1xf32>
 //       CHECK:   scf.for %[[arg3:.*]] = %[[c0]] to %[[v1]] step %[[c1]] {
 //       CHECK:     %[[v9:.*]] = affine.min #[[$map0]](%[[arg3]])[%[[v1]]]
 //       CHECK:     %[[v10:.*]] = subview %[[arg2]][%[[arg3]]] [%[[v9]]] [1]  : memref<?xf32> to memref<?xf32, #[[$map1]]>
 //       CHECK:     %[[v11:.*]] = subview %[[v8]][0] [%[[v9]]] [1]  : memref<1xf32> to memref<?xf32>
 //       CHECK:     scf.for %[[arg4:.*]] = %[[c0]] to %[[v0]] step %[[c3]] {
 //       CHECK:       %[[v12:.*]] = affine.apply #[[$map2]](%[[arg3]], %[[arg4]])
 //       CHECK:       %[[v13:.*]] = affine.min #[[$map3]](%[[arg3]], %[[arg4]])[%[[v2]]]
 //       CHECK:       %[[v14:.*]] = subview %arg0[%12] [%13] [1]  : memref<?xf32> to memref<?xf32, #[[$map1]]>

mlir/test/Conversion/SCFToGPU/no_blocks_no_threads.mlir

func @one_d_loop(%A : memref<?xf32>, %B : memref<?xf32>) {
   // CHECK-THREADS-NEXT: gpu.launch blocks(%[[B0:.*]], %[[B1:.*]], %[[B2:.*]]) in (%{{.*}} = %[[ONE]], %{{.*}} = %[[ONE]], %{{.*}}0 = %[[ONE]]) threads(%[[T0:.*]], %[[T1:.*]], %[[T2:.*]]) in (%{{.*}} = %[[BOUND]], %{{.*}} = %[[ONE]], %{{.*}} = %[[ONE]])
   // CHECK-BLOCKS-NEXT: gpu.launch blocks(%[[B0:.*]], %[[B1:.*]], %[[B2:.*]]) in (%{{.*}} = %[[BOUND]], %{{.*}} = %[[ONE]], %{{.*}}0 = %[[ONE]]) threads(%[[T0:.*]], %[[T1:.*]], %[[T2:.*]]) in (%{{.*}} = %[[ONE]], %{{.*}} = %[[ONE]], %{{.*}} = %[[ONE]])
   affine.for %i = 0 to 42 {
   // CHECK-THREADS-NEXT: %[[INDEX:.*]] = addi %{{.*}}, %[[T0]]
   // CHECK-THREADS-NEXT: load %{{.*}}[%[[INDEX]]]
   // CHECK-BLOCKS-NEXT: %[[INDEX:.*]] = addi %{{.*}}, %[[B0]]
   // CHECK-BLOCKS-NEXT: load %{{.*}}[%[[INDEX]]]
     %0 = load %A[%i] : memref<?xf32>
-    store %0, %B[%i] : memref<?xf32>
+    memref.store %0, %B[%i] : memref<?xf32>
     // CHECK-THREADS: gpu.terminator
     // CHECK-BLOCKS: gpu.terminator
   }
   return
 }
 

mlir/test/Conversion/SCFToGPU/parallel_loop.mlir

 // RUN: mlir-opt -convert-parallel-loops-to-gpu -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // 2-d parallel loop mapped to block.y and block.x
 
 func @parallel_loop_bidy_bidx(%arg0 : index, %arg1 : index, %arg2 : index,
                               %arg3 : index, %arg4 : index,
                               %buf : memref<?x?xf32>,
                               %res : memref<?x?xf32>) {
   %step = constant 2 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%arg4, %step)  {
     %val = load %buf[%i0, %i1] : memref<?x?xf32>
-    store %val, %res[%i1, %i0] : memref<?x?xf32>
+    memref.store %val, %res[%i1, %i0] : memref<?x?xf32>
   } { mapping = [{processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}, {processor = 0, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}] }
   return
 }
 
 // CHECK:       #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)>
 // CHECK:       #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)>
 
 // CHECK:       module {
 // CHECK-LABEL:   func @parallel_loop_bidy_bidx(
 // CHECK-SAME:                                  [[VAL_0:%.*]]: index, [[VAL_1:%.*]]: index, [[VAL_2:%.*]]: index, [[VAL_3:%.*]]: index, [[VAL_4:%.*]]: index, [[VAL_5:%.*]]: memref<?x?xf32>, [[VAL_6:%.*]]: memref<?x?xf32>) {
 // CHECK:           [[VAL_7:%.*]] = constant 2 : index
 // CHECK:           [[VAL_8:%.*]] = constant 1 : index
 // CHECK:           [[VAL_9:%.*]] = affine.apply #[[$MAP0]]([[VAL_2]]){{\[}}[[VAL_0]], [[VAL_4]]]
 // CHECK:           [[VAL_10:%.*]] = affine.apply #[[$MAP0]]([[VAL_3]]){{\[}}[[VAL_1]], [[VAL_7]]]
 // CHECK:           gpu.launch blocks([[VAL_11:%.*]], [[VAL_12:%.*]], [[VAL_13:%.*]]) in ([[VAL_14:%.*]] = [[VAL_10]], [[VAL_15:%.*]] = [[VAL_9]], [[VAL_16:%.*]] = [[VAL_8]]) threads([[VAL_17:%.*]], [[VAL_18:%.*]], [[VAL_19:%.*]]) in ([[VAL_20:%.*]] = [[VAL_8]], [[VAL_21:%.*]] = [[VAL_8]], [[VAL_22:%.*]] = [[VAL_8]]) {
 // CHECK:             [[VAL_23:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]){{\[}}[[VAL_4]], [[VAL_0]]]
 // CHECK:             [[VAL_24:%.*]] = affine.apply #[[$MAP1]]([[VAL_11]]){{\[}}[[VAL_7]], [[VAL_1]]]
 // CHECK:             [[VAL_25:%.*]] = load [[VAL_5]]{{\[}}[[VAL_23]], [[VAL_24]]] : memref<?x?xf32>
-// CHECK:             store [[VAL_25]], [[VAL_6]]{{\[}}[[VAL_24]], [[VAL_23]]] : memref<?x?xf32>
+// CHECK:             memref.store [[VAL_25]], [[VAL_6]]{{\[}}[[VAL_24]], [[VAL_23]]] : memref<?x?xf32>
 // CHECK:             gpu.terminator
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 // CHECK:       }
 
 // -----
 
 // tiled 2-d parallel loop mapped to block.y and block.x and thread.y and thread.x.
 
 func @parallel_loop_tiled(%arg0 : index, %arg1 : index, %arg2 : index,
                         %arg3 : index,
                         %buf : memref<?x?xf32>,
                         %res : memref<?x?xf32>) {
   %zero = constant 0 : index
   %one = constant 1 : index
   %four = constant 4 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%four, %four)  {
     scf.parallel (%si0, %si1) = (%zero, %zero) to (%four, %four)
                                             step (%one, %one)  {
       %idx0 = addi %i0, %si0 : index
       %idx1 = addi %i1, %si1 : index
       %val = load %buf[%idx0, %idx1] : memref<?x?xf32>
-      store %val, %res[%idx1, %idx0] : memref<?x?xf32>
+      memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
     } { mapping = [
         {processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
         {processor = 3, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
      ] }
   } { mapping = [
       {processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
       {processor = 0, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
     ] }

 // CHECK:           gpu.launch blocks([[VAL_40:%.*]], [[VAL_41:%.*]], [[VAL_42:%.*]]) in ([[VAL_43:%.*]] = [[VAL_37]], [[VAL_44:%.*]] = [[VAL_36]], [[VAL_45:%.*]] = [[VAL_35]]) threads([[VAL_46:%.*]], [[VAL_47:%.*]], [[VAL_48:%.*]]) in ([[VAL_49:%.*]] = [[VAL_39]], [[VAL_50:%.*]] = [[VAL_38]], [[VAL_51:%.*]] = [[VAL_35]]) {
 // CHECK:             [[VAL_52:%.*]] = affine.apply #[[$MAP1]]([[VAL_41]]){{\[}}[[VAL_34]], [[VAL_26]]]
 // CHECK:             [[VAL_53:%.*]] = affine.apply #[[$MAP1]]([[VAL_40]]){{\[}}[[VAL_34]], [[VAL_27]]]
 // CHECK:             [[VAL_54:%.*]] = affine.apply #[[$MAP1]]([[VAL_47]]){{\[}}[[VAL_33]], [[VAL_32]]]
 // CHECK:             [[VAL_55:%.*]] = affine.apply #[[$MAP1]]([[VAL_46]]){{\[}}[[VAL_33]], [[VAL_32]]]
 // CHECK:             [[VAL_56:%.*]] = addi [[VAL_52]], [[VAL_54]] : index
 // CHECK:             [[VAL_57:%.*]] = addi [[VAL_53]], [[VAL_55]] : index
 // CHECK:             [[VAL_58:%.*]] = load [[VAL_30]]{{\[}}[[VAL_56]], [[VAL_57]]] : memref<?x?xf32>
-// CHECK:             store [[VAL_58]], [[VAL_31]]{{\[}}[[VAL_57]], [[VAL_56]]] : memref<?x?xf32>
+// CHECK:             memref.store [[VAL_58]], [[VAL_31]]{{\[}}[[VAL_57]], [[VAL_56]]] : memref<?x?xf32>
 // CHECK:             gpu.terminator
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 // CHECK:       }
 
 // -----
 
 // 2-d parallel loop mapped to block.y and sequential
 
 func @parallel_loop_bidy_seq(%arg0 : index, %arg1 : index, %arg2 : index,
                              %arg3 : index, %arg4 : index,
                              %buf : memref<?x?xf32>,
                              %res : memref<?x?xf32>) {
   %step = constant 2 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%arg4, %step)  {
     %val = load %buf[%i0, %i1] : memref<?x?xf32>
-    store %val, %res[%i1, %i0] : memref<?x?xf32>
+    memref.store %val, %res[%i1, %i0] : memref<?x?xf32>
   } { mapping = [
       {processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
       {processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
     ] }
   return
 }
 
 // CHECK:       #[[$MAP0:.*]] = affine_map<(d0)[s0, s1] -> ((d0 - s0) ceildiv s1)>
 // CHECK:       #[[$MAP1:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s0 + s1)>
 
 // CHECK:       module {
 // CHECK-LABEL:   func @parallel_loop_bidy_seq(
 // CHECK-SAME:                                 [[VAL_59:%.*]]: index, [[VAL_60:%.*]]: index, [[VAL_61:%.*]]: index, [[VAL_62:%.*]]: index, [[VAL_63:%.*]]: index, [[VAL_64:%.*]]: memref<?x?xf32>, [[VAL_65:%.*]]: memref<?x?xf32>) {
 // CHECK:           [[VAL_66:%.*]] = constant 2 : index
 // CHECK:           [[VAL_67:%.*]] = constant 1 : index
 // CHECK:           [[VAL_68:%.*]] = affine.apply #[[$MAP0]]([[VAL_61]]){{\[}}[[VAL_59]], [[VAL_63]]]
 // CHECK:           gpu.launch blocks([[VAL_69:%.*]], [[VAL_70:%.*]], [[VAL_71:%.*]]) in ([[VAL_72:%.*]] = [[VAL_67]], [[VAL_73:%.*]] = [[VAL_68]], [[VAL_74:%.*]] = [[VAL_67]]) threads([[VAL_75:%.*]], [[VAL_76:%.*]], [[VAL_77:%.*]]) in ([[VAL_78:%.*]] = [[VAL_67]], [[VAL_79:%.*]] = [[VAL_67]], [[VAL_80:%.*]] = [[VAL_67]]) {
 // CHECK:             [[VAL_81:%.*]] = affine.apply #[[$MAP1]]([[VAL_70]]){{\[}}[[VAL_63]], [[VAL_59]]]
 // CHECK:             scf.for [[VAL_82:%.*]] = [[VAL_60]] to [[VAL_62]] step [[VAL_66]] {
 // CHECK:               [[VAL_83:%.*]] = load [[VAL_64]]{{\[}}[[VAL_81]], [[VAL_82]]] : memref<?x?xf32>
-// CHECK:               store [[VAL_83]], [[VAL_65]]{{\[}}[[VAL_82]], [[VAL_81]]] : memref<?x?xf32>
+// CHECK:               memref.store [[VAL_83]], [[VAL_65]]{{\[}}[[VAL_82]], [[VAL_81]]] : memref<?x?xf32>
 // CHECK:             }
 // CHECK:             gpu.terminator
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 // CHECK:       }
 
 // -----
func @parallel_loop_tiled_seq(%arg0 : index, %arg1 : index, %arg2 : index,
   %four = constant 4 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%four, %four)  {
     scf.parallel (%si0, %si1) = (%zero, %zero) to (%four, %four)
                                             step (%one, %one)  {
       %idx0 = addi %i0, %si0 : index
       %idx1 = addi %i1, %si1 : index
       %val = load %buf[%idx0, %idx1] : memref<?x?xf32>
-      store %val, %res[%idx1, %idx0] : memref<?x?xf32>
+      memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
     } { mapping = [
         {processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
         {processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
       ] }
   } { mapping = [
       {processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
       {processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
     ] }

 // CHECK:           gpu.launch blocks([[VAL_96:%.*]], [[VAL_97:%.*]], [[VAL_98:%.*]]) in ([[VAL_99:%.*]] = [[VAL_93]], [[VAL_100:%.*]] = [[VAL_94]], [[VAL_101:%.*]] = [[VAL_93]]) threads([[VAL_102:%.*]], [[VAL_103:%.*]], [[VAL_104:%.*]]) in ([[VAL_105:%.*]] = [[VAL_93]], [[VAL_106:%.*]] = [[VAL_95]], [[VAL_107:%.*]] = [[VAL_93]]) {
 // CHECK:             [[VAL_108:%.*]] = affine.apply #[[$MAP1]]([[VAL_97]]){{\[}}[[VAL_92]], [[VAL_84]]]
 // CHECK:             scf.for [[VAL_109:%.*]] = [[VAL_85]] to [[VAL_87]] step [[VAL_92]] {
 // CHECK:               [[VAL_110:%.*]] = affine.apply #[[$MAP1]]([[VAL_103]]){{\[}}[[VAL_91]], [[VAL_90]]]
 // CHECK:               scf.for [[VAL_111:%.*]] = [[VAL_90]] to [[VAL_92]] step [[VAL_91]] {
 // CHECK:                 [[VAL_112:%.*]] = addi [[VAL_108]], [[VAL_110]] : index
 // CHECK:                 [[VAL_113:%.*]] = addi [[VAL_109]], [[VAL_111]] : index
 // CHECK:                 [[VAL_114:%.*]] = load [[VAL_88]]{{\[}}[[VAL_112]], [[VAL_113]]] : memref<?x?xf32>
-// CHECK:                 store [[VAL_114]], [[VAL_89]]{{\[}}[[VAL_113]], [[VAL_112]]] : memref<?x?xf32>
+// CHECK:                 memref.store [[VAL_114]], [[VAL_89]]{{\[}}[[VAL_113]], [[VAL_112]]] : memref<?x?xf32>
 // CHECK:               }
 // CHECK:             }
 // CHECK:             gpu.terminator
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 // CHECK:       }
 
scf.parallel (%arg3, %arg4) = (%c0, %c0) to (%0, %1) step (%c2, %c3) {
       %14 = dim %arg2, %c1 : memref<?x?xf32, #map0>
       %15 = affine.min #map2(%arg4)[%14]
       %16 = std.subview %arg2[%arg3, %arg4][%13, %15][%c1, %c1] : memref<?x?xf32, #map0> to memref<?x?xf32, #map3>
       scf.parallel (%arg5, %arg6) = (%c0, %c0) to (%squared_min, %5) step (%c1, %c1) {
         %17 = load %6[%arg5, %arg6] : memref<?x?xf32, #map3>
         %18 = load %11[%arg5, %arg6] : memref<?x?xf32, #map3>
         %19 = load %16[%arg5, %arg6] : memref<?x?xf32, #map3>
         %20 = addf %17, %18 : f32
-        store %20, %16[%arg5, %arg6] : memref<?x?xf32, #map3>
+        memref.store %20, %16[%arg5, %arg6] : memref<?x?xf32, #map3>
         scf.yield
       } {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 3 : i64}, {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 4 : i64}]}
       scf.yield
     } {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 0 : i64}, {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 1 : i64}]}
     return
   }
 }
 

 // CHECK:             scf.if [[VAL_46]] {
 // CHECK:               [[VAL_47:%.*]] = affine.apply #[[$MAP2]]([[VAL_23]]){{\[}}%[[C1]], %[[C0]]]
 // CHECK:               [[VAL_48:%.*]] = cmpi slt, [[VAL_47]], [[VAL_33]] : index
 // CHECK:               scf.if [[VAL_48]] {
 // CHECK:                 [[VAL_49:%.*]] = load [[VAL_34]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
 // CHECK:                 [[VAL_50:%.*]] = load [[VAL_39]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
 // CHECK:                 [[VAL_51:%.*]] = load [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
 // CHECK:                 [[VAL_52:%.*]] = addf [[VAL_49]], [[VAL_50]] : f32
-// CHECK:                 store [[VAL_52]], [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
+// CHECK:                 memref.store [[VAL_52]], [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
 // CHECK:               }
 // CHECK:             }
 // CHECK:             gpu.terminator
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 // CHECK:       }
 
func @parallel_loop_loop_variant_bound(%arg0 : index, %arg1 : index, %arg2 : index,
   %four = constant 4 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%four, %four)  {
     scf.parallel (%si0, %si1) = (%zero, %zero) to (%i0, %i1)
                                             step (%one, %one)  {
       %idx0 = addi %i0, %si0 : index
       %idx1 = addi %i1, %si1 : index
       %val = load %buf[%idx0, %idx1] : memref<?x?xf32>
-      store %val, %res[%idx1, %idx0] : memref<?x?xf32>
+      memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
     } { mapping = [
         {processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
         {processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
       ] }
   } { mapping = [
       {processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
       {processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
     ] }

mlir/test/Conversion/SCFToGPU/step_one.mlir

// CHECK-11-SAME: threads
           // CHECK-22-NEXT:   %[[j:.*]] = addi %{{.*}}, %{{.*}} : index
           // CHECK-22-NEXT:   %[[ii:.*]] = addi %{{.*}}, %{{.*}} : index
           // CHECK-22-NEXT:   %[[jj:.*]] = addi %{{.*}}, %{{.*}} : index
 
           // Using remapped values instead of loop iterators.
           // CHECK-11:        {{.*}} = load %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
           // CHECK-22:        {{.*}} = load %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
           %0 = load %A[%i, %j, %ii, %jj] : memref<?x?x?x?xf32>
-          // CHECK-11-NEXT:   store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
-          // CHECK-22-NEXT:   store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
-          store %0, %B[%i, %j, %ii, %jj] : memref<?x?x?x?xf32>
+          // CHECK-11-NEXT:   memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
+          // CHECK-22-NEXT:   memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
+          memref.store %0, %B[%i, %j, %ii, %jj] : memref<?x?x?x?xf32>
 
           // CHECK-11: gpu.terminator
           // CHECK-22: gpu.terminator
         }
       }
     }
   }
   return
 }
 

mlir/test/Conversion/SCFToGPU/step_positive.mlir

affine.for %j = 3 to 19 step 7 {
       //     iv = thread(block)_id * step + lower_bound
       // CHECK:      %[[prod_i:.*]] = muli %{{.*}}, %{{.*}} : index
       // CHECK-NEXT: %[[i:.*]] = addi %{{.*}}, %[[prod_i]] : index
       // CHECK-NEXT: %[[prod_j:.*]] = muli %{{.*}}, %{{.*}} : index
       // CHECK-NEXT: %[[j:.*]] = addi %{{.*}}, %[[prod_j]] : index
 
       // CHECK:     {{.*}} = load %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
       %0 = load %A[%i, %j] : memref<?x?xf32>
-      // CHECK:     store {{.*}}, %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
-      store %0, %B[%i, %j] : memref<?x?xf32>
+      // CHECK:     memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
+      memref.store %0, %B[%i, %j] : memref<?x?xf32>
     }
   }
   return
 }

mlir/test/Conversion/SCFToSPIRV/for.mlir

func @loop_kernel(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
   // CHECK:        spv.AccessChain {{%.*}}[%[[ZERO2]], %[[INDEX2]]]
   // CHECK:        %[[INCREMENT:.*]] = spv.IAdd %[[INDVAR]], %[[STEP]] : i32
   // CHECK:        spv.Branch ^[[HEADER]](%[[INCREMENT]] : i32)
   // CHECK:      ^[[MERGE]]
   // CHECK:        spv.mlir.merge
   // CHECK:      }
   scf.for %arg4 = %lb to %ub step %step {
     %1 = load %arg2[%arg4] : memref<10xf32>
-    store %1, %arg3[%arg4] : memref<10xf32>
+    memref.store %1, %arg3[%arg4] : memref<10xf32>
   }
   return
 }
 
 // CHECK-LABEL: @loop_yield
 func @loop_yield(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
   // CHECK: %[[LB:.*]] = spv.constant 4 : i32
   %lb = constant 4 : index
func @loop_yield(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
   %result:2 = scf.for %i0 = %lb to %ub step %step iter_args(%si = %s0, %sj = %s1) -> (f32, f32) {
     %sn = addf %si, %si : f32
     scf.yield %sn, %sn : f32, f32
   }
   // CHECK-DAG: %[[OUT1:.*]] = spv.Load "Function" %[[VAR1]] : f32
   // CHECK-DAG: %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32
   // CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT1]] : f32
   // CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT2]] : f32
-  store %result#0, %arg3[%lb] : memref<10xf32>
-  store %result#1, %arg3[%ub] : memref<10xf32>
+  memref.store %result#0, %arg3[%lb] : memref<10xf32>
+  memref.store %result#1, %arg3[%ub] : memref<10xf32>
   return
 }
 
 } // end module

mlir/test/Conversion/SCFToSPIRV/if.mlir

func @kernel_simple_selection(%arg2 : memref<10xf32>, %arg3 : i1) {
   // CHECK-NEXT:  [[TRUE]]:
   // CHECK:         spv.Branch [[MERGE]]
   // CHECK-NEXT:  [[MERGE]]:
   // CHECK-NEXT:    spv.mlir.merge
   // CHECK-NEXT:  }
   // CHECK-NEXT:  spv.Return
 
   scf.if %arg3 {
-    store %value, %arg2[%i] : memref<10xf32>
+    memref.store %value, %arg2[%i] : memref<10xf32>
   }
   return
 }
 
 // CHECK-LABEL: @kernel_nested_selection
 func @kernel_nested_selection(%arg3 : memref<10xf32>, %arg4 : memref<10xf32>, %arg5 : i1, %arg6 : i1) {
   %i = constant 0 : index
   %j = constant 9 : index
func @kernel_nested_selection(%arg3 : memref<10xf32>, %arg4 : memref<10xf32>, %arg5 : i1, %arg6 : i1) {
   // CHECK-NEXT:  [[MERGE_TOP]]:
   // CHECK-NEXT:    spv.mlir.merge
   // CHECK-NEXT:  }
   // CHECK-NEXT:  spv.Return
 
   scf.if %arg5 {
     scf.if %arg6 {
       %value = load %arg3[%i] : memref<10xf32>
-      store %value, %arg4[%i] : memref<10xf32>
+      memref.store %value, %arg4[%i] : memref<10xf32>
     } else {
       %value = load %arg4[%i] : memref<10xf32>
-      store %value, %arg3[%i] : memref<10xf32>
+      memref.store %value, %arg3[%i] : memref<10xf32>
     }
   } else {
     scf.if %arg6 {
       %value = load %arg3[%j] : memref<10xf32>
-      store %value, %arg4[%j] : memref<10xf32>
+      memref.store %value, %arg4[%j] : memref<10xf32>
     } else {
       %value = load %arg4[%j] : memref<10xf32>
-      store %value, %arg3[%j] : memref<10xf32>
+      memref.store %value, %arg3[%j] : memref<10xf32>
     }
   }
   return
 }
 
 // CHECK-LABEL: @simple_if_yield
 func @simple_if_yield(%arg2 : memref<10xf32>, %arg3 : i1) {
   // CHECK: %[[VAR1:.*]] = spv.Variable : !spv.ptr<f32, Function>
%0:2 = scf.if %arg3 -> (f32, f32) {
     scf.yield %c0, %c1 : f32, f32
   } else {
     %c0 = constant 2.0 : f32
     %c1 = constant 3.0 : f32
     scf.yield %c1, %c0 : f32, f32
   }
   %i = constant 0 : index
   %j = constant 1 : index
-  store %0#0, %arg2[%i] : memref<10xf32>
-  store %0#1, %arg2[%j] : memref<10xf32>
+  memref.store %0#0, %arg2[%i] : memref<10xf32>
+  memref.store %0#1, %arg2[%j] : memref<10xf32>
   return
 }
 
 // TODO: The transformation should only be legal if VariablePointer capability
 // is supported. This test is still useful to make sure we can handle scf op
 // result with type change.
 func @simple_if_yield_type_change(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>, %arg4 : i1) {
   // CHECK-LABEL: @simple_if_yield_type_change
func @simple_if_yield_type_change(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>, %arg4 : i1) {
   // CHECK:       spv.Return
   %i = constant 0 : index
   %value = constant 0.0 : f32
   %0 = scf.if %arg4 -> (memref<10xf32>) {
     scf.yield %arg2 : memref<10xf32>
   } else {
     scf.yield %arg3 : memref<10xf32>
   }
-  store %value, %0[%i] : memref<10xf32>
+  memref.store %value, %0[%i] : memref<10xf32>
   return
 }
 
 } // end module

mlir/test/Conversion/SPIRVToLLVM/lower-host-to-llvm-calls.mlir

 // RUN: mlir-opt --lower-host-to-llvm %s | FileCheck %s
-  
 module attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]>, {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 128, 64]> : vector<3xi32>}>} {
 
   //       CHECK: llvm.mlir.global linkonce @__spv__foo_bar_arg_0_descriptor_set0_binding0() : !llvm.struct<(array<6 x i32>)>
   //       CHECK: llvm.func @__spv__foo_bar()
 
   //       CHECK: spv.module @__spv__foo
   //       CHECK:   spv.globalVariable @bar_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer>
   //       CHECK:   spv.func @__spv__foo_bar
-  
   //       CHECK:   spv.EntryPoint "GLCompute" @__spv__foo_bar
   //       CHECK:   spv.ExecutionMode @__spv__foo_bar "LocalSize", 1, 1, 1
 
   // CHECK-LABEL: @main
   //       CHECK:   %[[SRC:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<1 x i64>, array<1 x i64>)>
   //  CHECK-NEXT:   %[[DEST:.*]] = llvm.mlir.addressof @__spv__foo_bar_arg_0_descriptor_set0_binding0 : !llvm.ptr<struct<(array<6 x i32>)>>
   //  CHECK-NEXT:   llvm.mlir.constant(false) : i1
   //  CHECK-NEXT:   "llvm.intr.memcpy"(%[[DEST]], %[[SRC]], %[[SIZE:.*]], %{{.*}}) : (!llvm.ptr<struct<(array<6 x i32>)>>, !llvm.ptr<i32>, i64, i1) -> ()
module attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]>, {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 128, 64]> : vector<3xi32>}>} {
 
   gpu.module @foo {
     gpu.func @bar(%arg0: memref<6xi32>) kernel attributes {spv.entry_point_abi = {local_size = dense<1> : vector<3xi32>}} {
       gpu.return
     }
   }
 
   func @main() {
-    %buffer = alloc() : memref<6xi32>
+    %buffer = memref.alloc() : memref<6xi32>
     %one = constant 1 : index
     gpu.launch_func @foo::@bar blocks in (%one, %one, %one)
         threads in (%one, %one, %one) args(%buffer : memref<6xi32>)
     return
   }
 }

mlir/test/Conversion/StandardToLLVM/calling-convention.mlir

 // CHECK-LABEL: llvm.func @return_var_memref
 func @return_var_memref(%arg0: memref<4x3xf32>) -> memref<*xf32> {
   // Match the construction of the unranked descriptor.
   // CHECK: %[[ALLOCA:.*]] = llvm.alloca
   // CHECK: %[[MEMORY:.*]] = llvm.bitcast %[[ALLOCA]]
   // CHECK: %[[DESC_0:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[DESC_1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_0]][0]
   // CHECK: %[[DESC_2:.*]] = llvm.insertvalue %[[MEMORY]], %[[DESC_1]][1]
-  %0 = memref_cast %arg0: memref<4x3xf32> to memref<*xf32>
+  %0 = memref.cast %arg0: memref<4x3xf32> to memref<*xf32>
 
   // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : index)
   // CHECK: %[[TWO:.*]] = llvm.mlir.constant(2 : index)
   // These sizes may depend on the data layout, not matching specific values.
   // CHECK: %[[PTR_SIZE:.*]] = llvm.mlir.constant
   // CHECK: %[[IDX_SIZE:.*]] = llvm.mlir.constant
 
   // CHECK: %[[DOUBLE_PTR_SIZE:.*]] = llvm.mul %[[TWO]], %[[PTR_SIZE]]

 // CHECK-LABEL: llvm.func @return_two_var_memref
 func @return_two_var_memref(%arg0: memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) {
   // Match the construction of the unranked descriptor.
   // CHECK: %[[ALLOCA:.*]] = llvm.alloca
   // CHECK: %[[MEMORY:.*]] = llvm.bitcast %[[ALLOCA]]
   // CHECK: %[[DESC_0:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
   // CHECK: %[[DESC_1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_0]][0]
   // CHECK: %[[DESC_2:.*]] = llvm.insertvalue %[[MEMORY]], %[[DESC_1]][1]
-  %0 = memref_cast %arg0 : memref<4x3xf32> to memref<*xf32>
+  %0 = memref.cast %arg0 : memref<4x3xf32> to memref<*xf32>
 
   // Only check that we allocate the memory for each operand of the "return"
   // separately, even if both operands are the same value. The calling
   // convention requires the caller to free them and the caller cannot know
   // whether they are the same value or not.
   // CHECK: %[[ALLOCATED_1:.*]] = llvm.call @malloc(%{{.*}})
   // CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[DESC_2]][1]
   // CHECK: "llvm.intr.memcpy"(%[[ALLOCATED_1]], %[[SOURCE_1]], %{{.*}}, %[[FALSE:.*]])

mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir

 //  CHECK-NEXT:  %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
 //  CHECK-NEXT:  llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
-  %0 = alloc(%arg0, %arg1) : memref<?x42x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x42x?xf32>
 //  CHECK-NEXT:  llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
   return %0 : memref<?x42x?xf32>
 }
 
 // CHECK-LABEL: func @mixed_dealloc
 func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 // CHECK-NEXT:  %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK-NEXT:  llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
-  dealloc %arg0 : memref<?x42x?xf32>
+  memref.dealloc %arg0 : memref<?x42x?xf32>
 // CHECK-NEXT:  llvm.return
   return
 }
 
 // CHECK-LABEL: func @dynamic_alloc(
 //       CHECK:   %[[M:.*]]: i64, %[[N:.*]]: i64) -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
 //  CHECK-NEXT:  %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 //  CHECK-NEXT:  %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : i64
 //  CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 //  CHECK-NEXT:  llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
 //  CHECK-NEXT:  llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
 //  CHECK-NEXT:  llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
 //  CHECK-NEXT:  llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   return %0 : memref<?x?xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dynamic_alloca
 // CHECK: %[[M:.*]]: i64, %[[N:.*]]: i64) -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 func @dynamic_alloca(%arg0: index, %arg1: index) -> memref<?x?xf32> {
 //  CHECK-NEXT:  %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64
 //  CHECK-NEXT:  %[[num_elems:.*]] = llvm.mul %[[N]], %[[M]] : i64
 //  CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 //  CHECK-NEXT:  %[[allocated:.*]] = llvm.alloca %[[sz_bytes]] x f32 : (i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[allocated]], %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[allocated]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
 //  CHECK-NEXT:  llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  llvm.insertvalue %[[st1]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  %0 = alloca(%arg0, %arg1) : memref<?x?xf32>
+  %0 = memref.alloca(%arg0, %arg1) : memref<?x?xf32>
 
 // Test with explicitly specified alignment. llvm.alloca takes care of the
 // alignment. The same pointer is thus used for allocation and aligned
 // accesses.
 // CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x f32 {alignment = 32 : i64} : (i64) -> !llvm.ptr<f32>
 // CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32>
+  memref.alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32>
   return %0 : memref<?x?xf32>
 }
 
 // CHECK-LABEL: func @dynamic_dealloc
 func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK-NEXT:  %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK-NEXT:  llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
-  dealloc %arg0 : memref<?x?xf32>
+  memref.dealloc %arg0 : memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 // ALIGNED-ALLOC-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> {
 // ALIGNED-ALLOC-NEXT:  %[[sz1:.*]] = llvm.mlir.constant(32 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[sz2:.*]] = llvm.mlir.constant(18 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // ALIGNED-ALLOC-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // ALIGNED-ALLOC-NEXT:  %[[bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // ALIGNED-ALLOC-NEXT:  %[[alignment:.*]] = llvm.mlir.constant(32 : index) : i64
 // ALIGNED-ALLOC-NEXT:  %[[allocated:.*]] = llvm.call @aligned_alloc(%[[alignment]], %[[bytes]]) : (i64, i64) -> !llvm.ptr<i8>
 // ALIGNED-ALLOC-NEXT:  llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
-  %0 = alloc() {alignment = 32} : memref<32x18xf32>
+  %0 = memref.alloc() {alignment = 32} : memref<32x18xf32>
   // Do another alloc just to test that we have a unique declaration for
   // aligned_alloc.
   // ALIGNED-ALLOC:  llvm.call @aligned_alloc
-  %1 = alloc() {alignment = 64} : memref<4096xf32>
+  %1 = memref.alloc() {alignment = 64} : memref<4096xf32>
 
   // Alignment is to element type boundaries (minimum 16 bytes).
   // ALIGNED-ALLOC:  %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c32]]
-  %2 = alloc() : memref<4096xvector<8xf32>>
+  %2 = memref.alloc() : memref<4096xvector<8xf32>>
   // The minimum alignment is 16 bytes unless explicitly specified.
   // ALIGNED-ALLOC:  %[[c16:.*]] = llvm.mlir.constant(16 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c16]],
-  %3 = alloc() : memref<4096xvector<2xf32>>
+  %3 = memref.alloc() : memref<4096xvector<2xf32>>
   // ALIGNED-ALLOC:  %[[c8:.*]] = llvm.mlir.constant(8 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c8]],
-  %4 = alloc() {alignment = 8} : memref<1024xvector<4xf32>>
+  %4 = memref.alloc() {alignment = 8} : memref<1024xvector<4xf32>>
   // Bump the memref allocation size if its size is not a multiple of alignment.
   // ALIGNED-ALLOC:       %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.mlir.constant(1 : index) : i64
   // ALIGNED-ALLOC-NEXT:  llvm.sub
   // ALIGNED-ALLOC-NEXT:  llvm.add
   // ALIGNED-ALLOC-NEXT:  llvm.urem
   // ALIGNED-ALLOC-NEXT:  %[[SIZE_ALIGNED:.*]] = llvm.sub
   // ALIGNED-ALLOC-NEXT:  llvm.call @aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]])
-  %5 = alloc() {alignment = 32} : memref<100xf32>
+  %5 = memref.alloc() {alignment = 32} : memref<100xf32>
   // Bump alignment to the next power of two if it isn't.
   // ALIGNED-ALLOC:  %[[c128:.*]] = llvm.mlir.constant(128 : index) : i64
   // ALIGNED-ALLOC:  llvm.call @aligned_alloc(%[[c128]]
-  %6 = alloc(%N) : memref<?xvector<18xf32>>
+  %6 = memref.alloc(%N) : memref<?xvector<18xf32>>
   return %0 : memref<32x18xf32>
 }
 
 // CHECK-LABEL: func @mixed_load(
 // CHECK-COUNT-2: !llvm.ptr<f32>,
 // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64
 // CHECK:         %[[I:.*]]: i64,
 // CHECK:         %[[J:.*]]: i64)

 // CHECK-NEXT:  %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK-NEXT:  %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
 // CHECK-NEXT:  %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
 // CHECK-NEXT:  %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK-NEXT:  [[C1:%.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK-NEXT:  [[C3:%.*]] = llvm.mlir.constant(3 : i32) : i32
 // CHECK-NEXT:  [[C1_1:%.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK-NEXT:  "llvm.intr.prefetch"(%[[addr]], [[C1]], [[C3]], [[C1_1]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
-  prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32>
+  memref.prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32>
 // CHECK:  [[C0:%.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:  [[C0_1:%.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:  [[C1_2:%.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:  "llvm.intr.prefetch"(%{{.*}}, [[C0]], [[C0_1]], [[C1_2]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
-  prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32>
+  memref.prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32>
 // CHECK:  [[C0_2:%.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:  [[C2:%.*]] = llvm.mlir.constant(2 : i32) : i32
 // CHECK:  [[C0_3:%.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:  "llvm.intr.prefetch"(%{{.*}}, [[C0_2]], [[C2]], [[C0_3]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
-  prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32>
+  memref.prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @dynamic_store
 // CHECK-SAME:         %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<f32>
 // CHECK-SAME:         %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<f32>
 // CHECK-SAME:         %[[ARG2:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG3:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG4:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG5:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG6:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[I:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[J:[a-zA-Z0-9]*]]: i64
 func @dynamic_store(%dynamic : memref<?x?xf32>, %i : index, %j : index, %val : f32) {
 //       CHECK:  %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
 //  CHECK-NEXT:  %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
 //  CHECK-NEXT:  %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
-  store %val, %dynamic[%i, %j] : memref<?x?xf32>
+  memref.store %val, %dynamic[%i, %j] : memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @mixed_store
 // CHECK-SAME:         %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<f32>
 // CHECK-SAME:         %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<f32>
 // CHECK-SAME:         %[[ARG2:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG3:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG4:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG5:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[ARG6:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[I:[a-zA-Z0-9]*]]: i64
 // CHECK-SAME:         %[[J:[a-zA-Z0-9]*]]: i64
 func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32) {
 //       CHECK:  %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 //  CHECK-NEXT:  %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
 //  CHECK-NEXT:  %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
 //  CHECK-NEXT:  %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 //  CHECK-NEXT:  llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
-  store %val, %mixed[%i, %j] : memref<42x?xf32>
+  memref.store %val, %mixed[%i, %j] : memref<42x?xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_static_to_dynamic
 func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %static : memref<10x42xf32> to memref<?x?xf32>
+  %0 = memref.cast %static : memref<10x42xf32> to memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_static_to_mixed
 func @memref_cast_static_to_mixed(%static : memref<10x42xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %static : memref<10x42xf32> to memref<?x42xf32>
+  %0 = memref.cast %static : memref<10x42xf32> to memref<?x42xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_dynamic_to_static
 func @memref_cast_dynamic_to_static(%dynamic : memref<?x?xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %dynamic : memref<?x?xf32> to memref<10x12xf32>
+  %0 = memref.cast %dynamic : memref<?x?xf32> to memref<10x12xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_dynamic_to_mixed
 func @memref_cast_dynamic_to_mixed(%dynamic : memref<?x?xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %dynamic : memref<?x?xf32> to memref<?x12xf32>
+  %0 = memref.cast %dynamic : memref<?x?xf32> to memref<?x12xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_mixed_to_dynamic
 func @memref_cast_mixed_to_dynamic(%mixed : memref<42x?xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %mixed : memref<42x?xf32> to memref<?x?xf32>
+  %0 = memref.cast %mixed : memref<42x?xf32> to memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_mixed_to_static
 func @memref_cast_mixed_to_static(%mixed : memref<42x?xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %mixed : memref<42x?xf32> to memref<42x1xf32>
+  %0 = memref.cast %mixed : memref<42x?xf32> to memref<42x1xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_mixed_to_mixed
 func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
 // CHECK-NOT: llvm.bitcast
-  %0 = memref_cast %mixed : memref<42x?xf32> to memref<?x1xf32>
+  %0 = memref.cast %mixed : memref<42x?xf32> to memref<?x1xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_ranked_to_unranked
 func @memref_cast_ranked_to_unranked(%arg : memref<42x2x?xf32>) {
 // CHECK-DAG:  %[[c:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK-DAG:  %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>>
 // CHECK-DAG:  llvm.store %{{.*}}, %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>>
 // CHECK-DAG:  %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>> to !llvm.ptr<i8>
 // CHECK-DAG:  %[[r:.*]] = llvm.mlir.constant(3 : i64) : i64
 // CHECK    :  llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
 // CHECK-DAG:  llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr<i8>)>
 // CHECK-DAG:  llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
-  %0 = memref_cast %arg : memref<42x2x?xf32> to memref<*xf32>
+  %0 = memref.cast %arg : memref<42x2x?xf32> to memref<*xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_cast_unranked_to_ranked
 func @memref_cast_unranked_to_ranked(%arg : memref<*xf32>) {
 //      CHECK: %[[p:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
 // CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>>
-  %0 = memref_cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
+  %0 = memref.cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
   return
 }
 
 // CHECK-LABEL: func @mixed_memref_dim
 func @mixed_memref_dim(%mixed : memref<42x?x?x13x?xf32>) {
 // CHECK: llvm.mlir.constant(42 : index) : i64
   %c0 = constant 0 : index
   %0 = dim %mixed, %c0 : memref<42x?x?x13x?xf32>

mlir/test/Conversion/StandardToLLVM/convert-static-memref-ops.mlir

 // BAREPTR-NEXT:  %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // BAREPTR-NEXT:  llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
 // BAREPTR-NEXT:  %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<f32>
 // BAREPTR-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // BAREPTR-NEXT:  llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // BAREPTR-NEXT:  llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // BAREPTR-NEXT:  %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
 // BAREPTR-NEXT:  llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
-  %0 = alloc() : memref<f32>
+  %0 = memref.alloc() : memref<f32>
   return %0 : memref<f32>
 }
 
 // -----
 
 // CHECK-LABEL: func @zero_d_dealloc
 // BAREPTR-LABEL: func @zero_d_dealloc(%{{.*}}: !llvm.ptr<f32>) {
 func @zero_d_dealloc(%arg0: memref<f32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK-NEXT:  %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK-NEXT:  llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
 
 // BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // BAREPTR-NEXT: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // BAREPTR-NEXT: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
-  dealloc %arg0 : memref<f32>
+  memref.dealloc %arg0 : memref<f32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @aligned_1d_alloc(
 // BAREPTR-LABEL: func @aligned_1d_alloc(
 func @aligned_1d_alloc() -> memref<42xf32> {

 // BAREPTR-NEXT:  %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : i64
 // BAREPTR-NEXT:  %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : i64
 // BAREPTR-NEXT:  %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : i64 to !llvm.ptr<f32>
 // BAREPTR-NEXT:  llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
 // BAREPTR-NEXT:  llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
 // BAREPTR-NEXT:  llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
 // BAREPTR-NEXT:  %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
 // BAREPTR-NEXT:  llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
-  %0 = alloc() {alignment = 8} : memref<42xf32>
+  %0 = memref.alloc() {alignment = 8} : memref<42xf32>
   return %0 : memref<42xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @static_alloc() -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 // BAREPTR-LABEL: func @static_alloc() -> !llvm.ptr<f32> {
 func @static_alloc() -> memref<32x18xf32> {
 //      CHECK:  %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK-NEXT:  %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // CHECK-NEXT:  %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
 // CHECK-NEXT:  llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
 
 // BAREPTR:      %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
 // BAREPTR-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
- %0 = alloc() : memref<32x18xf32>
+ %0 = memref.alloc() : memref<32x18xf32>
  return %0 : memref<32x18xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @static_alloca() -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> {
 func @static_alloca() -> memref<32x18xf32> {
 // CHECK-NEXT:  %[[sz1:.*]] = llvm.mlir.constant(32 : index) : i64
 // CHECK-NEXT:  %[[sz2:.*]] = llvm.mlir.constant(18 : index) : i64
 // CHECK-NEXT:  %[[st2:.*]] = llvm.mlir.constant(1 : index) : i64
 // CHECK-NEXT:  %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
 // CHECK-NEXT:  %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK-NEXT:  %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // CHECK-NEXT:  %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
 // CHECK-NEXT:  %[[allocated:.*]] = llvm.alloca %[[size_bytes]] x f32 : (i64) -> !llvm.ptr<f32>
- %0 = alloca() : memref<32x18xf32>
+ %0 = memref.alloca() : memref<32x18xf32>
 
  // Test with explicitly specified alignment. llvm.alloca takes care of the
  // alignment. The same pointer is thus used for allocation and aligned
  // accesses.
  // CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x f32 {alignment = 32 : i64} : (i64) -> !llvm.ptr<f32>
  // CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
  // CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
  // CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
- alloca() {alignment = 32} : memref<32x18xf32>
+ memref.alloca() {alignment = 32} : memref<32x18xf32>
  return %0 : memref<32x18xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @static_dealloc
 // BAREPTR-LABEL: func @static_dealloc(%{{.*}}: !llvm.ptr<f32>) {
 func @static_dealloc(%static: memref<10x8xf32>) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // CHECK-NEXT:  %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // CHECK-NEXT:  llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
 
 // BAREPTR:      %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
 // BAREPTR-NEXT: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
-  dealloc %static : memref<10x8xf32>
+  memref.dealloc %static : memref<10x8xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @zero_d_load
 // BAREPTR-LABEL: func @zero_d_load(%{{.*}}: !llvm.ptr<f32>) -> f32
 func @zero_d_load(%arg0: memref<f32>) -> f32 {

 // BAREPTR-LABEL: func @zero_d_store
 // BAREPTR-SAME: (%[[A:.*]]: !llvm.ptr<f32>, %[[val:.*]]: f32)
 func @zero_d_store(%arg0: memref<f32>, %arg1: f32) {
 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // CHECK-NEXT:  llvm.store %{{.*}}, %[[ptr]] : !llvm.ptr<f32>
 
 // BAREPTR:      %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
 // BAREPTR-NEXT: llvm.store %[[val]], %[[ptr]] : !llvm.ptr<f32>
-  store %arg1, %arg0[] : memref<f32>
+  memref.store %arg1, %arg0[] : memref<f32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @static_store
 // CHECK-SAME:         %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<f32>
 // CHECK-SAME:         %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<f32>

 //  CHECK-NEXT:  llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
 
 // BAREPTR:      %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64
 // BAREPTR-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
 // BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
 // BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
 // BAREPTR-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
-  store %val, %static[%i, %j] : memref<10x42xf32>
+  memref.store %val, %static[%i, %j] : memref<10x42xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @static_memref_dim
 // BAREPTR-LABEL: func @static_memref_dim(%{{.*}}: !llvm.ptr<f32>) {
 func @static_memref_dim(%static : memref<42x32x15x13x27xf32>) {

mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir

 // CHECK-NEXT: %[[SCALE:[0-9]+]] = llvm.fmul %[[A]], %[[SPLAT]] : vector<4xf32>
 // CHECK-NEXT: llvm.return %[[SCALE]] : vector<4xf32>
 
 // CHECK-LABEL: func @view(
 // CHECK: %[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64, %[[ARG2:.*]]: i64
 func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: llvm.mlir.constant(2048 : index) : i64
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
-  %0 = alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
 
   // Test two dynamic sizes.
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[BASE_PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
   // CHECK: %[[SHIFTED_BASE_PTR:.*]] = llvm.getelementptr %[[BASE_PTR]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
   // CHECK: %[[CAST_SHIFTED_BASE_PTR:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
   // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[C0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(1 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  %1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
+  %1 = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
 
   // Test one dynamic size.
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
   // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
   // CHECK: %[[CAST_SHIFTED_BASE_PTR_2:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_2]] : !llvm.ptr<i8> to !llvm.ptr<f32>
   // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[C0_2]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(1 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  %3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
+  %3 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
 
   // Test static sizes.
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[BASE_PTR_3:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
   // CHECK: %[[SHIFTED_BASE_PTR_3:.*]] = llvm.getelementptr %[[BASE_PTR_3]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
   // CHECK: %[[CAST_SHIFTED_BASE_PTR_3:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_3]] : !llvm.ptr<i8> to !llvm.ptr<f32>
   // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_3]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[C0_3:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[C0_3]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(1 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(64 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
-  %5 = view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32>
+  %5 = memref.view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32>
 
   // Test view memory space.
   // CHECK: llvm.mlir.constant(2048 : index) : i64
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
-  %6 = alloc() : memref<2048xi8, 4>
+  %6 = memref.alloc() : memref<2048xi8, 4>
 
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
   // CHECK: %[[SHIFTED_BASE_PTR_4:.*]] = llvm.getelementptr %[[BASE_PTR_4]][%[[ARG2]]] : (!llvm.ptr<i8, 4>, i64) -> !llvm.ptr<i8, 4>
   // CHECK: %[[CAST_SHIFTED_BASE_PTR_4:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_4]] : !llvm.ptr<i8, 4> to !llvm.ptr<f32, 4>
   // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_4]], %{{.*}}[1] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[C0_4:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[C0_4]], %{{.*}}[2] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(1 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(64 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
-  %7 = view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>
+  %7 = memref.view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>
 
   return
 }
 
 // CHECK-LABEL: func @subview(
 // CHECK-COUNT-2: !llvm.ptr<f32>,
 // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64,
 // CHECK:         %[[ARG0:[a-zA-Z0-9]*]]: i64,

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -convert-std-to-llvm -split-input-file -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: func @address_space(
 // CHECK-SAME:    !llvm.ptr<f32, 7>
 func @address_space(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>, 7>) {
-  %0 = alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
+  %0 = memref.alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
   %1 = constant 7 : index
   // CHECK: llvm.load %{{.*}} : !llvm.ptr<f32, 5>
   %2 = load %0[%1] : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
   std.return
 }
 
 // -----
 

 //       CHECK:    llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:   llvm.extractvalue {{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:    llvm.insertvalue {{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:   llvm.extractvalue {{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:    llvm.insertvalue {{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:   llvm.extractvalue {{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 //       CHECK:    llvm.insertvalue {{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
 func @transpose(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  %0 = transpose %arg0 (i, j, k) -> (k, i, j) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d0 * s2 + d1)>>
+  %0 = memref.transpose %arg0 (i, j, k) -> (k, i, j) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d0 * s2 + d1)>>
   return
 }
 
 // -----
 
 // CHECK: llvm.mlir.global external @gv0() : !llvm.array<2 x f32>
-global_memref @gv0 : memref<2xf32> = uninitialized
+memref.global @gv0 : memref<2xf32> = uninitialized
 
 // CHECK: llvm.mlir.global private @gv1() : !llvm.array<2 x f32>
-global_memref "private" @gv1 : memref<2xf32>
+memref.global "private" @gv1 : memref<2xf32>
 
 // CHECK: llvm.mlir.global external @gv2(dense<{{\[\[}}0.000000e+00, 1.000000e+00, 2.000000e+00], [3.000000e+00, 4.000000e+00, 5.000000e+00]]> : tensor<2x3xf32>) : !llvm.array<2 x array<3 x f32>>
-global_memref @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]>
+memref.global @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]>
 
 // Test 1D memref.
 // CHECK-LABEL: func @get_gv0_memref
 func @get_gv0_memref() {
-  %0 = get_global_memref @gv0 : memref<2xf32>
+  %0 = memref.get_global @gv0 : memref<2xf32>
   // CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : i64
   // CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64
   // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr<array<2 x f32>>
   // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]], %[[ZERO]]] : (!llvm.ptr<array<2 x f32>>, i64, i64) -> !llvm.ptr<f32>
   // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
   // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<f32>
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
func @get_gv2_memref() {
   // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[DIM0]], {{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.insertvalue %[[STRIDE1]], {{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
 
-  %0 = get_global_memref @gv2 : memref<2x3xf32>
+  %0 = memref.get_global @gv2 : memref<2x3xf32>
   return
 }
 
 // Test scalar memref.
 // CHECK: llvm.mlir.global external @gv3(1.000000e+00 : f32) : f32
-global_memref @gv3 : memref<f32> = dense<1.0>
+memref.global @gv3 : memref<f32> = dense<1.0>
 
 // CHECK-LABEL: func @get_gv3_memref
 func @get_gv3_memref() {
   // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv3 : !llvm.ptr<f32>
   // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
   // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
   // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<f32>
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
   // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
   // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
   // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
-  %0 = get_global_memref @gv3 : memref<f32>
+  %0 = memref.get_global @gv3 : memref<f32>
   return
 }
 
 // This should not trigger an assertion by creating an LLVM::CallOp with a
 // nullptr result type.
 
 // CHECK-LABEL: @call_zero_result_func
 func @call_zero_result_func() {

mlir/test/Conversion/StandardToSPIRV/alloc.mlir

 // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -convert-std-to-spirv -canonicalize -verify-diagnostics %s -o - | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // std allocation/deallocation ops
 //===----------------------------------------------------------------------===//
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_workgroup_mem(%arg0 : index, %arg1 : index) {
-    %0 = alloc() : memref<4x5xf32, 3>
+    %0 = memref.alloc() : memref<4x5xf32, 3>
     %1 = load %0[%arg0, %arg1] : memref<4x5xf32, 3>
-    store %1, %0[%arg0, %arg1] : memref<4x5xf32, 3>
-    dealloc %0 : memref<4x5xf32, 3>
+    memref.store %1, %0[%arg0, %arg1] : memref<4x5xf32, 3>
+    memref.dealloc %0 : memref<4x5xf32, 3>
     return
   }
 }
 //     CHECK: spv.globalVariable @[[VAR:.+]] : !spv.ptr<!spv.struct<(!spv.array<20 x f32, stride=4>)>, Workgroup>
 //     CHECK: func @alloc_dealloc_workgroup_mem
-// CHECK-NOT:   alloc
+// CHECK-NOT:   memref.alloc
 //     CHECK:   %[[PTR:.+]] = spv.mlir.addressof @[[VAR]]
 //     CHECK:   %[[LOADPTR:.+]] = spv.AccessChain %[[PTR]]
 //     CHECK:   %[[VAL:.+]] = spv.Load "Workgroup" %[[LOADPTR]] : f32
 //     CHECK:   %[[STOREPTR:.+]] = spv.AccessChain %[[PTR]]
 //     CHECK:   spv.Store "Workgroup" %[[STOREPTR]], %[[VAL]] : f32
-// CHECK-NOT:   dealloc
+// CHECK-NOT:   memref.dealloc
 //     CHECK:   spv.Return
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_workgroup_mem(%arg0 : index, %arg1 : index) {
-    %0 = alloc() : memref<4x5xi16, 3>
+    %0 = memref.alloc() : memref<4x5xi16, 3>
     %1 = load %0[%arg0, %arg1] : memref<4x5xi16, 3>
-    store %1, %0[%arg0, %arg1] : memref<4x5xi16, 3>
-    dealloc %0 : memref<4x5xi16, 3>
+    memref.store %1, %0[%arg0, %arg1] : memref<4x5xi16, 3>
+    memref.dealloc %0 : memref<4x5xi16, 3>
     return
   }
 }
 
 //       CHECK: spv.globalVariable @__workgroup_mem__{{[0-9]+}}
 //  CHECK-SAME:   !spv.ptr<!spv.struct<(!spv.array<20 x i32, stride=4>)>, Workgroup>
 // CHECK_LABEL: spv.func @alloc_dealloc_workgroup_mem
 //       CHECK:   %[[VAR:.+]] = spv.mlir.addressof @__workgroup_mem__0

 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @two_allocs() {
-    %0 = alloc() : memref<4x5xf32, 3>
-    %1 = alloc() : memref<2x3xi32, 3>
+    %0 = memref.alloc() : memref<4x5xf32, 3>
+    %1 = memref.alloc() : memref<2x3xi32, 3>
     return
   }
 }
 
 //  CHECK-DAG: spv.globalVariable @__workgroup_mem__{{[0-9]+}}
 // CHECK-SAME:   !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4>)>, Workgroup>
 //  CHECK-DAG: spv.globalVariable @__workgroup_mem__{{[0-9]+}}
 // CHECK-SAME:   !spv.ptr<!spv.struct<(!spv.array<20 x f32, stride=4>)>, Workgroup>
 //      CHECK: spv.func @two_allocs()
 //      CHECK: spv.Return
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @two_allocs_vector() {
-    %0 = alloc() : memref<4xvector<4xf32>, 3>
-    %1 = alloc() : memref<2xvector<2xi32>, 3>
+    %0 = memref.alloc() : memref<4xvector<4xf32>, 3>
+    %1 = memref.alloc() : memref<2xvector<2xi32>, 3>
     return
   }
 }
 
 //  CHECK-DAG: spv.globalVariable @__workgroup_mem__{{[0-9]+}}
 // CHECK-SAME:   !spv.ptr<!spv.struct<(!spv.array<2 x vector<2xi32>, stride=8>)>, Workgroup>
 //  CHECK-DAG: spv.globalVariable @__workgroup_mem__{{[0-9]+}}
 // CHECK-SAME:   !spv.ptr<!spv.struct<(!spv.array<4 x vector<4xf32>, stride=16>)>, Workgroup>
 //      CHECK: spv.func @two_allocs_vector()
 //      CHECK: spv.Return
 
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_dynamic_workgroup_mem(%arg0 : index) {
     // expected-error @+2 {{unhandled allocation type}}
-    // expected-error @+1 {{'std.alloc' op operand #0 must be index}}
-    %0 = alloc(%arg0) : memref<4x?xf32, 3>
+    // expected-error @+1 {{'memref.alloc' op operand #0 must be index}}
+    %0 = memref.alloc(%arg0) : memref<4x?xf32, 3>
     return
   }
 }
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_mem() {
     // expected-error @+1 {{unhandled allocation type}}
-    %0 = alloc() : memref<4x5xf32>
+    %0 = memref.alloc() : memref<4x5xf32>
     return
   }
 }
 
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_dynamic_workgroup_mem(%arg0 : memref<4x?xf32, 3>) {
     // expected-error @+2 {{unhandled deallocation type}}
-    // expected-error @+1 {{'std.dealloc' op operand #0 must be memref of any type values}}
-    dealloc %arg0 : memref<4x?xf32, 3>
+    // expected-error @+1 {{'memref.dealloc' op operand #0 must be memref of any type values}}
+    memref.dealloc %arg0 : memref<4x?xf32, 3>
     return
   }
 }
 
 // -----
 
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
   }
 {
   func @alloc_dealloc_mem(%arg0 : memref<4x5xf32>) {
     // expected-error @+2 {{unhandled deallocation type}}
     // expected-error @+1 {{op operand #0 must be memref of any type values}}
-    dealloc %arg0 : memref<4x5xf32>
+    memref.dealloc %arg0 : memref<4x5xf32>
     return
   }
 }

mlir/test/Conversion/StandardToSPIRV/legalization.mlir

 func @fold_static_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index, %arg5 : f32) {
   // CHECK-NOT: subview
   // CHECK: [[C2:%.*]] = constant 2 : index
   // CHECK: [[C3:%.*]] = constant 3 : index
   // CHECK: [[STRIDE1:%.*]] = muli [[ARG3]], [[C2]] : index
   // CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
   // CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[C3]] : index
   // CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
-  // CHECK: store [[ARG5]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
+  // CHECK: memref.store [[ARG5]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
   %0 = subview %arg0[%arg1, %arg2][4, 4][2, 3] :
     memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [64, 3]>
-  store %arg5, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [64, 3]>
+  memref.store %arg5, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [64, 3]>
   return
 }
 
 // CHECK-LABEL: @fold_dynamic_stride_subview_with_store
 // CHECK-SAME: [[ARG0:%.*]]: memref<12x32xf32>, [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index, [[ARG5:%.*]]: index, [[ARG6:%.*]]: index, [[ARG7:%.*]]: f32
 func @fold_dynamic_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index, %arg5 : index, %arg6 : index, %arg7 : f32) {
   // CHECK-NOT: subview
   // CHECK: [[STRIDE1:%.*]] = muli [[ARG3]], [[ARG5]] : index
   // CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
   // CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[ARG6]] : index
   // CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
-  // CHECK: store [[ARG7]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
+  // CHECK: memref.store [[ARG7]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
   %0 = subview %arg0[%arg1, %arg2][4, 4][%arg5, %arg6] :
     memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [?, ?]>
-  store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
+  memref.store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
   return
 }
 
 // CHECK-LABEL: @fold_static_stride_subview_with_transfer_read
 // CHECK-SAME: [[ARG0:%.*]]: memref<12x32xf32>, [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index
 func @fold_static_stride_subview_with_transfer_read(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index) -> vector<4xf32> {
   // CHECK-NOT: subview
   // CHECK: [[F1:%.*]] = constant 1.000000e+00 : f32

mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir

func @load_store_zero_rank_float(%arg0: memref<f32>, %arg1: memref<f32>) {
   // CHECK-SAME: ] :
   //      CHECK: spv.Load "StorageBuffer" %{{.*}} : f32
   %0 = load %arg0[] : memref<f32>
   //      CHECK: [[ZERO2:%.*]] = spv.constant 0 : i32
   //      CHECK: spv.AccessChain [[ARG1]][
   // CHECK-SAME: [[ZERO2]], [[ZERO2]]
   // CHECK-SAME: ] :
   //      CHECK: spv.Store "StorageBuffer" %{{.*}} : f32
-  store %0, %arg1[] : memref<f32>
+  memref.store %0, %arg1[] : memref<f32>
   return
 }
 
 // CHECK-LABEL: @load_store_zero_rank_int
 // CHECK: [[ARG0:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>,
 // CHECK: [[ARG1:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>)
 func @load_store_zero_rank_int(%arg0: memref<i32>, %arg1: memref<i32>) {
   //      CHECK: [[ZERO1:%.*]] = spv.constant 0 : i32
   //      CHECK: spv.AccessChain [[ARG0]][
   // CHECK-SAME: [[ZERO1]], [[ZERO1]]
   // CHECK-SAME: ] :
   //      CHECK: spv.Load "StorageBuffer" %{{.*}} : i32
   %0 = load %arg0[] : memref<i32>
   //      CHECK: [[ZERO2:%.*]] = spv.constant 0 : i32
   //      CHECK: spv.AccessChain [[ARG1]][
   // CHECK-SAME: [[ZERO2]], [[ZERO2]]
   // CHECK-SAME: ] :
   //      CHECK: spv.Store "StorageBuffer" %{{.*}} : i32
-  store %0, %arg1[] : memref<i32>
+  memref.store %0, %arg1[] : memref<i32>
   return
 }
 
 } // end module
 
 // -----
 
 // Check that access chain indices are properly adjusted if non-32-bit types are
func @store_i8(%arg0: memref<i8>, %value: i8) {
   //     CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
   //     CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32
   //     CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
   //     CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32
   //     CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32
   //     CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
   //     CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
   //     CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
-  store %value, %arg0[] : memref<i8>
+  memref.store %value, %arg0[] : memref<i8>
   return
 }
 
 // CHECK-LABEL: @store_i16
 //       CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32, %[[ARG2:.+]]: i32)
 func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
   //     CHECK: %[[ZERO:.+]] = spv.constant 0 : i32
   //     CHECK: %[[OFFSET:.+]] = spv.constant 0 : i32
func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
   //     CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
   //     CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG2]], %[[MASK1]] : i32
   //     CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
   //     CHECK: %[[TWO2:.+]] = spv.constant 2 : i32
   //     CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[FLAT_IDX]], %[[TWO2]] : i32
   //     CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
   //     CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
   //     CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
-  store %value, %arg0[%index] : memref<10xi16>
+  memref.store %value, %arg0[%index] : memref<10xi16>
   return
 }
 
 // CHECK-LABEL: @store_i32
 func @store_i32(%arg0: memref<i32>, %value: i32) {
   //     CHECK: spv.Store
   // CHECK-NOT: spv.AtomicAnd
   // CHECK-NOT: spv.AtomicOr
-  store %value, %arg0[] : memref<i32>
+  memref.store %value, %arg0[] : memref<i32>
   return
 }
 
 // CHECK-LABEL: @store_f32
 func @store_f32(%arg0: memref<f32>, %value: f32) {
   //     CHECK: spv.Store
   // CHECK-NOT: spv.AtomicAnd
   // CHECK-NOT: spv.AtomicOr
-  store %value, %arg0[] : memref<f32>
+  memref.store %value, %arg0[] : memref<f32>
   return
 }
 
 } // end module
 
 // -----
 
 // Check that access chain indices are properly adjusted if non-16/32-bit types
func @store_i8(%arg0: memref<i8>, %value: i8) {
   //     CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
   //     CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32
   //     CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
   //     CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32
   //     CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32
   //     CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
   //     CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
   //     CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
-  store %value, %arg0[] : memref<i8>
+  memref.store %value, %arg0[] : memref<i8>
   return
 }
 
 // CHECK-LABEL: @store_i16
 func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
   //     CHECK: spv.Store
   // CHECK-NOT: spv.AtomicAnd
   // CHECK-NOT: spv.AtomicOr
-  store %value, %arg0[%index] : memref<10xi16>
+  memref.store %value, %arg0[%index] : memref<10xi16>
   return
 }
 
 } // end module
 
 // -----
 
 //===----------------------------------------------------------------------===//

mlir/test/Conversion/StandardToSPIRV/subview-to-spirv.mlir

func @fold_static_stride_subview
   //     CHECK: %[[T2:.*]] = muli %[[ARG4]], %[[ARG2]]
   //     CHECK: %[[T3:.*]] = addi %[[T2]], %[[C2]]
   //     CHECK: %[[LOADVAL:.*]] = load %[[ARG0]][%[[T1]], %[[T3]]]
   //     CHECK: %[[STOREVAL:.*]] = math.sqrt %[[LOADVAL]]
   //     CHECK: %[[T6:.*]] = muli %[[ARG3]], %[[C3]]
   //     CHECK: %[[T7:.*]] = addi %[[ARG1]], %[[T6]]
   //     CHECK: %[[T8:.*]] = muli %[[ARG4]], %[[ARG2]]
   //     CHECK: %[[T9:.*]] = addi %[[T8]], %[[C2]]
-  //     CHECK: store %[[STOREVAL]], %[[ARG0]][%[[T7]], %[[T9]]]
+  //     CHECK: memref.store %[[STOREVAL]], %[[ARG0]][%[[T7]], %[[T9]]]
   %0 = subview %arg0[%arg1, 2][4, 4][3, %arg2] : memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [96, ?]>
   %1 = load %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
   %2 = math.sqrt %1 : f32
-  store %2, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
+  memref.store %2, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
   return
 }
 
 } // end module

mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir

 // RUN: mlir-opt %s -convert-vector-to-scf -split-input-file -allow-unregistered-dialect | FileCheck %s
 // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -split-input-file -allow-unregistered-dialect | FileCheck %s --check-prefix=FULL-UNROLL
 
 // CHECK-LABEL: func @materialize_read_1d() {
 func @materialize_read_1d() {
   %f0 = constant 0.0: f32
-  %A = alloc () : memref<7x42xf32>
+  %A = memref.alloc () : memref<7x42xf32>
   affine.for %i0 = 0 to 7 step 4 {
     affine.for %i1 = 0 to 42 step 4 {
       %f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
       %ip1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
       %f2 = vector.transfer_read %A[%i0, %ip1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
       %ip2 = affine.apply affine_map<(d0) -> (d0 + 2)> (%i1)
       %f3 = vector.transfer_read %A[%i0, %ip2], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
       %ip3 = affine.apply affine_map<(d0) -> (d0 + 3)> (%i1)
func @materialize_read_1d() {
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @materialize_read_1d_partially_specialized
 func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %dyn4 : index) {
   %f0 = constant 0.0: f32
-  %A = alloc (%dyn1, %dyn2, %dyn4) : memref<7x?x?x42x?xf32>
+  %A = memref.alloc (%dyn1, %dyn2, %dyn4) : memref<7x?x?x42x?xf32>
   affine.for %i0 = 0 to 7 {
     affine.for %i1 = 0 to %dyn1 {
       affine.for %i2 = 0 to %dyn2 {
         affine.for %i3 = 0 to 42 step 2 {
           affine.for %i4 = 0 to %dyn4 {
             %f1 = vector.transfer_read %A[%i0, %i1, %i2, %i3, %i4], %f0 {permutation_map = affine_map<(d0, d1, d2, d3, d4) -> (d3)>} : memref<7x?x?x42x?xf32>, vector<4xf32>
             %i3p1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i3)
             %f2 = vector.transfer_read %A[%i0, %i1, %i2, %i3p1, %i4], %f0 {permutation_map = affine_map<(d0, d1, d2, d3, d4) -> (d3)>} : memref<7x?x?x42x?xf32>, vector<4xf32>
             // Add a dummy use to prevent dead code elimination from removing
             // transfer read ops.
             "dummy_use"(%f1, %f2) : (vector<4xf32>, vector<4xf32>) -> ()
           }
         }
       }
     }
   }
-  // CHECK: %[[tensor:[0-9]+]] = alloc
+  // CHECK: %[[tensor:[0-9]+]] = memref.alloc
   // CHECK-NOT: {{.*}} dim %[[tensor]], %c0
   // CHECK-NOT: {{.*}} dim %[[tensor]], %c3
   return
 }
 
 // -----
 
 // CHECK: #[[$ADD:map.*]] = affine_map<(d0, d1) -> (d0 + d1)>
 
 // CHECK-LABEL: func @materialize_read(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   %f0 = constant 0.0: f32
-  // CHECK-DAG:  %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
+  // CHECK-DAG:  %[[ALLOC:.*]] = memref.alloca() : memref<5x4xvector<3xf32>>
   // CHECK-DAG:  %[[C0:.*]] = constant 0 : index
   // CHECK-DAG:  %[[C1:.*]] = constant 1 : index
   // CHECK-DAG:  %[[C3:.*]] = constant 3 : index
   // CHECK-DAG:  %[[C4:.*]] = constant 4 : index
   // CHECK-DAG:  %[[C5:.*]] = constant 5 : index
-  //     CHECK:  %{{.*}} = alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
+  //     CHECK:  %{{.*}} = memref.alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
   // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %{{.*}} step 3 {
   // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %{{.*}} {
   // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %{{.*}} {
   // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %{{.*}} step 5 {
   // CHECK-NEXT:          scf.for %[[I4:.*]] = %[[C0]] to %[[C3]] step %[[C1]] {
   // CHECK-NEXT:            scf.for %[[I5:.*]] = %[[C0]] to %[[C4]] step %[[C1]] {
   // CHECK-NEXT:              scf.for %[[I6:.*]] = %[[C0]] to %[[C5]] step %[[C1]] {
   // CHECK:                     %[[VIDX:.*]] = index_cast %[[I4]]
func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   // CHECK-NEXT:}
 
   // Check that I0 + I4 (of size 3) read from first index load(L0, ...) and write into last index store(..., I4)
   // Check that I3 + I6 (of size 5) read from last index load(..., L3) and write into first index store(I6, ...)
   // Other dimensions are just accessed with I1, I2 resp.
-  %A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
+  %A = memref.alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
   affine.for %i0 = 0 to %M step 3 {
     affine.for %i1 = 0 to %N {
       affine.for %i2 = 0 to %O {
         affine.for %i3 = 0 to %P step 5 {
           %f = vector.transfer_read %A[%i0, %i1, %i2, %i3], %f0 {permutation_map = affine_map<(d0, d1, d2, d3) -> (d3, 0, d0)>} : memref<?x?x?x?xf32>, vector<5x4x3xf32>
           // Add a dummy use to prevent dead code elimination from removing
           // transfer read ops.
           "dummy_use"(%f) : (vector<5x4x3xf32>) -> ()
         }
       }
     }
   }
   return
 }
 
 // -----
 
 // CHECK: #[[$ADD:map.*]] = affine_map<(d0, d1) -> (d0 + d1)>
 
 // CHECK-LABEL:func @materialize_write(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
-  // CHECK-DAG:  %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
+  // CHECK-DAG:  %[[ALLOC:.*]] = memref.alloca() : memref<5x4xvector<3xf32>>
   // CHECK-DAG:  %{{.*}} = constant dense<1.000000e+00> : vector<5x4x3xf32>
   // CHECK-DAG:  %[[C0:.*]] = constant 0 : index
   // CHECK-DAG:  %[[C1:.*]] = constant 1 : index
   // CHECK-DAG:  %[[C3:.*]] = constant 3 : index
   // CHECK-DAG:  %[[C4:.*]] = constant 4 : index
   // CHECK-DAG:  %[[C5:.*]] = constant 5 : index
-  //     CHECK:  %{{.*}} = alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
+  //     CHECK:  %{{.*}} = memref.alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
   // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %{{.*}} step 3 {
   // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %{{.*}} step 4 {
   // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %{{.*}} {
   // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %{{.*}} step 5 {
   // CHECK-NEXT:          %[[VECTOR_VIEW:.*]] = vector.type_cast {{.*}} : memref<5x4xvector<3xf32>>
   //      CHECK:          store %{{.*}}, {{.*}} : memref<vector<5x4x3xf32>>
   // CHECK-NEXT:          scf.for %[[I4:.*]] = %[[C0]] to %[[C3]] step %[[C1]] {
   // CHECK-NEXT:            scf.for %[[I5:.*]] = %[[C0]] to %[[C4]] step %[[C1]] {
func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   // CHECK-NEXT:}
   //
   // Check that I0 + I4 (of size 3) read from last index load(..., I4) and write into first index store(S0, ...)
   // Check that I1 + I5 (of size 4) read from second index load(..., I5, ...) and write into second index store(..., S1, ...)
   // Check that I3 + I6 (of size 5) read from first index load(I6, ...) and write into last index store(..., S3)
   // Other dimension is just accessed with I2.
-  %A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
+  %A = memref.alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
   %f1 = constant dense<1.000000e+00> : vector<5x4x3xf32>
   affine.for %i0 = 0 to %M step 3 {
     affine.for %i1 = 0 to %N step 4 {
       affine.for %i2 = 0 to %O {
         affine.for %i3 = 0 to %P step 5 {
           vector.transfer_write %f1, %A[%i0, %i1, %i2, %i3] {permutation_map = affine_map<(d0, d1, d2, d3) -> (d3, d1, d0)>} : vector<5x4x3xf32>, memref<?x?x?x?xf32>
         }
       }

 //  FULL-UNROLL-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  FULL-UNROLL-SAME:   %[[base:[a-zA-Z0-9]+]]: index
 
 func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x15xf32> {
   // CHECK: %[[cst:.*]] = constant 7.000000e+00 : f32
   %f7 = constant 7.0: f32
 
   // CHECK-DAG: %[[splat:.*]] = constant dense<7.000000e+00> : vector<15xf32>
-  // CHECK-DAG: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
+  // CHECK-DAG: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
   // CHECK-DAG: %[[C0:.*]] = constant 0 : index
   // CHECK-DAG: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
   // CHECK: affine.for %[[I:.*]] = 0 to 3 {
   // CHECK:   %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]]
   // CHECK:   %[[cond1:.*]] = cmpi slt, %[[add]], %[[dim]] : index
   // CHECK:   scf.if %[[cond1]] {
   // CHECK:     %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %[[cst]] : memref<?x?xf32>, vector<15xf32>
   // CHECK:     store %[[vec_1d]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>>

 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  CHECK-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 // FULL-UNROLL-LABEL: transfer_write_progressive(
 //  FULL-UNROLL-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  FULL-UNROLL-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  FULL-UNROLL-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 func @transfer_write_progressive(%A : memref<?x?xf32>, %base: index, %vec: vector<3x15xf32>) {
   // CHECK: %[[C0:.*]] = constant 0 : index
-  // CHECK: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
+  // CHECK: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
   // CHECK: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
   // CHECK: store %[[vec]], %[[vmemref]][] : memref<vector<3x15xf32>>
   // CHECK: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
   // CHECK: affine.for %[[I:.*]] = 0 to 3 {
   // CHECK:   %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]]
   // CHECK:   %[[cmp:.*]] = cmpi slt, %[[add]], %[[dim]] : index
   // CHECK:   scf.if %[[cmp]] {
   // CHECK:     %[[vec_1d:.*]] = load %0[%[[I]]] : memref<3xvector<15xf32>>

 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  CHECK-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 // FULL-UNROLL-LABEL: transfer_write_progressive_unmasked(
 //  FULL-UNROLL-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  FULL-UNROLL-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  FULL-UNROLL-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 func @transfer_write_progressive_unmasked(%A : memref<?x?xf32>, %base: index, %vec: vector<3x15xf32>) {
   // CHECK-NOT:    scf.if
-  // CHECK-NEXT: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
+  // CHECK-NEXT: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
   // CHECK-NEXT: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
   // CHECK-NEXT: store %[[vec]], %[[vmemref]][] : memref<vector<3x15xf32>>
   // CHECK-NEXT: affine.for %[[I:.*]] = 0 to 3 {
   // CHECK-NEXT:   %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]]
   // CHECK-NEXT:   %[[vec_1d:.*]] = load %0[%[[I]]] : memref<3xvector<15xf32>>
   // CHECK-NEXT:   vector.transfer_write %[[vec_1d]], %[[A]][%[[add]], %[[base]]] {masked = [false]} : vector<15xf32>, memref<?x?xf32>
 
   // FULL-UNROLL: %[[VEC0:.*]] = vector.extract %[[vec]][0] : vector<3x15xf32>

 }
 
 // CHECK-LABEL: transfer_read_minor_identity(
 //  CHECK-SAME:   %[[A:.*]]: memref<?x?x?x?xf32>) -> vector<3x3xf32>
 //       CHECK:   %[[c0:.*]] = constant 0 : index
 //       CHECK:   %[[cst:.*]] = constant 0.000000e+00 : f32
 //       CHECK:   %[[c2:.*]] = constant 2 : index
 //       CHECK:   %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32>
-//       CHECK:   %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
+//       CHECK:   %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
 //       CHECK:   %[[d:.*]] = dim %[[A]], %[[c2]] : memref<?x?x?x?xf32>
 //       CHECK:   affine.for %[[arg1:.*]] = 0 to 3 {
 //       CHECK:      %[[cmp:.*]] = cmpi slt, %[[arg1]], %[[d]] : index
 //       CHECK:      scf.if %[[cmp]] {
 //       CHECK:        %[[tr:.*]] = vector.transfer_read %[[A]][%[[c0]], %[[c0]], %[[arg1]], %[[c0]]], %[[cst]] : memref<?x?x?x?xf32>, vector<3xf32>
 //       CHECK:        store %[[tr]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
 //       CHECK:      } else {
 //       CHECK:        store %[[cst0]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
func @transfer_write_minor_identity(%A : vector<3x3xf32>, %B : memref<?x?x?x?xf32>) {
   return
 }
 
 // CHECK-LABEL: transfer_write_minor_identity(
 //  CHECK-SAME:   %[[A:.*]]: vector<3x3xf32>,
 //  CHECK-SAME:   %[[B:.*]]: memref<?x?x?x?xf32>)
 //       CHECK:   %[[c0:.*]] = constant 0 : index
 //       CHECK:   %[[c2:.*]] = constant 2 : index
-//       CHECK:   %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
+//       CHECK:   %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
 //       CHECK:   %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>>
 //       CHECK:   store %[[A]], %[[cast]][] : memref<vector<3x3xf32>>
 //       CHECK:   %[[d:.*]] = dim %[[B]], %[[c2]] : memref<?x?x?x?xf32>
 //       CHECK:   affine.for %[[arg2:.*]] = 0 to 3 {
 //       CHECK:      %[[cmp:.*]] = cmpi slt, %[[arg2]], %[[d]] : index
 //       CHECK:      scf.if %[[cmp]] {
 //       CHECK:        %[[tmp:.*]] = load %[[m]][%[[arg2]]] : memref<3xvector<3xf32>>
 //       CHECK:        vector.transfer_write %[[tmp]], %[[B]][%[[c0]], %[[c0]], %[[arg2]], %[[c0]]] : vector<3xf32>, memref<?x?x?x?xf32>

mlir/test/Dialect/Affine/SuperVectorize/vector_utils.mlir

 // RUN: mlir-opt %s -affine-super-vectorizer-test -vector-shape-ratio 4 -vector-shape-ratio 8 2>&1 | FileCheck %s
 // RUN: mlir-opt %s -affine-super-vectorizer-test -vector-shape-ratio 2 -vector-shape-ratio 5 -vector-shape-ratio 2 2>&1 | FileCheck %s -check-prefix=TEST-3x4x5x8
 // RUN: mlir-opt %s -affine-super-vectorizer-test -vectorize-affine-loop-nest 2>&1 | FileCheck %s -check-prefix=VECNEST
 
 func @vector_add_2d(%arg0: index, %arg1: index) -> f32 {
   // Nothing should be matched in this first block.
-  // CHECK-NOT:matched: {{.*}} = alloc{{.*}}
+  // CHECK-NOT:matched: {{.*}} = memref.alloc{{.*}}
   // CHECK-NOT:matched: {{.*}} = constant 0{{.*}}
   // CHECK-NOT:matched: {{.*}} = constant 1{{.*}}
-  %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %1 = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %2 = alloc(%arg0, %arg1) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %2 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   %c0 = constant 0 : index
   %cst = constant 1.000000e+00 : f32
 
   // CHECK:matched: {{.*}} constant dense{{.*}} with shape ratio: 2, 32
   %cst_1 = constant dense<1.000000e+00> : vector<8x256xf32>
   // CHECK:matched: {{.*}} constant dense{{.*}} with shape ratio: 1, 3, 7, 2, 1
   %cst_a = constant dense<1.000000e+00> : vector<1x3x7x8x8xf32>
   // CHECK-NOT:matched: {{.*}} constant dense{{.*}} with shape ratio: 1, 3, 7, 1{{.*}}

mlir/test/Dialect/Affine/SuperVectorize/vectorize_1d.mlir

affine.for %i9 = 0 to %N {
        %a9 = affine.load %A[%i9, %i8 + %i9] : memref<?x?xf32>
      }
    }
    return
 }
 
 // CHECK-LABEL: func @vector_add_2d
 func @vector_add_2d(%M : index, %N : index) -> f32 {
-  %A = alloc (%M, %N) : memref<?x?xf32, 0>
-  %B = alloc (%M, %N) : memref<?x?xf32, 0>
-  %C = alloc (%M, %N) : memref<?x?xf32, 0>
+  %A = memref.alloc (%M, %N) : memref<?x?xf32, 0>
+  %B = memref.alloc (%M, %N) : memref<?x?xf32, 0>
+  %C = memref.alloc (%M, %N) : memref<?x?xf32, 0>
   %f1 = constant 1.0 : f32
   %f2 = constant 2.0 : f32
   affine.for %i0 = 0 to %M {
     affine.for %i1 = 0 to %N {
       // CHECK: %[[C1:.*]] = constant dense<1.000000e+00> : vector<128xf32>
       // CHECK: vector.transfer_write %[[C1]], {{.*}} : vector<128xf32>, memref<?x?xf32>
       // non-scoped %f1
       affine.store %f1, %A[%i0, %i1] : memref<?x?xf32, 0>
// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, %[[C2]] : memref<?x?x?xf32>
    %c1 = constant 1 : index
    %c2 = constant 2 : index
    %M = dim %A, %c0 : memref<?x?xf32>
    %N = dim %A, %c1 : memref<?x?xf32>
    %P = dim %B, %c2 : memref<?x?x?xf32>
 
 // CHECK:  affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
    affine.for %i16 = 0 to %M { // not vectorized, can't vectorize a vector load
-     %a16 = alloc(%M) : memref<?xvector<2xf32>>
+     %a16 = memref.alloc(%M) : memref<?xvector<2xf32>>
      %l16 = affine.load %a16[%i16] : memref<?xvector<2xf32>>
    }
    return
 }
 
 // CHECK-LABEL: func @vec_rejected_8
 func @vec_rejected_8(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %[[C0:.*]] = constant 0 : index

mlir/test/Dialect/Affine/SuperVectorize/vectorize_2d.mlir

affine.for %i4 = 0 to %N {
          %a5 = affine.load %A[%i4, %i5, %i3] : memref<?x?x?xf32>
        }
      }
    }
    return
 }
 
 func @vector_add_2d(%M : index, %N : index) -> f32 {
-  %A = alloc (%M, %N) : memref<?x?xf32, 0>
-  %B = alloc (%M, %N) : memref<?x?xf32, 0>
-  %C = alloc (%M, %N) : memref<?x?xf32, 0>
+  %A = memref.alloc (%M, %N) : memref<?x?xf32, 0>
+  %B = memref.alloc (%M, %N) : memref<?x?xf32, 0>
+  %C = memref.alloc (%M, %N) : memref<?x?xf32, 0>
   %f1 = constant 1.0 : f32
   %f2 = constant 2.0 : f32
   affine.for %i0 = 0 to %M {
     affine.for %i1 = 0 to %N {
       // CHECK: [[C1:%.*]] = constant dense<1.000000e+00> : vector<32x256xf32>
       // CHECK: vector.transfer_write [[C1]], {{.*}} : vector<32x256xf32>, memref<?x?xf32>
       // non-scoped %f1
       affine.store %f1, %A[%i0, %i1] : memref<?x?xf32, 0>

mlir/test/Dialect/Affine/affine-data-copy.mlir

func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<4096x4096xf32>) -> memref<4096x4096xf32> {
   }
   return %C : memref<4096x4096xf32>
 }
 
 // Buffers of size 128x128 get created here for all three matrices.
 
 // CHECK: affine.for %[[I:.*]] = 0 to 4096 step 128 {
 // CHECK:   affine.for %[[J:.*]] = 0 to 4096 step 128 {
-// CHECK:     [[BUFC:%[0-9]+]] = alloc() : memref<128x128xf32>
+// CHECK:     [[BUFC:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
 // The result matrix's copy gets hoisted out.
 // Result matrix copy-in.
 // CHECK:     affine.for %[[II:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:       affine.for %[[JJ:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:         affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
 // CHECK:         affine.store %{{.*}}, [[BUFC]][%[[II]] - %[[I]], %[[JJ]] - %[[J]]] : memref<128x128xf32>
 // CHECK:       }
 // CHECK:     }
 
 // LHS matrix copy-in.
 // CHECK:     affine.for %[[K:.*]] = 0 to 4096 step 128 {
-// CHECK:      [[BUFA:%[0-9]+]] = alloc() : memref<128x128xf32>
+// CHECK:      [[BUFA:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
 // CHECK:       affine.for %[[II:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:         affine.for %[[KK:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:           affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
 // CHECK:           affine.store %{{.*}}, [[BUFA]][%[[II]] - %[[I]], %[[KK]] - %[[K]]] : memref<128x128xf32>
 // CHECK:         }
 // CHECK:       }
 
 // RHS matrix copy-in.
-// CHECK:       [[BUFB:%[0-9]+]] = alloc() : memref<128x128xf32>
+// CHECK:       [[BUFB:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
 // CHECK:       affine.for %[[KK:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:         affine.for %[[JJ:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:           affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
 // CHECK:           affine.store %{{.*}}, [[BUFB]][%[[KK]] - %[[K]], %[[JJ]] - %[[J]]] : memref<128x128xf32>
 // CHECK:         }
 // CHECK:       }
 
 // Computation on the fast buffers.
 // CHECK:       affine.for %{{.*}} = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:         affine.for %{{.*}} = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:           affine.for %{{.*}} = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:             affine.load [[BUFA]][-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<128x128xf32>
 // CHECK:             affine.load [[BUFB]][-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<128x128xf32>
 // CHECK:             affine.load [[BUFC]][-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<128x128xf32>
 // CHECK:             mulf %{{.*}}, %{{.*}} : f32
 // CHECK:             addf %{{.*}}, %{{.*}} : f32
 // CHECK:             affine.store %{{.*}}, [[BUFC]][-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<128x128xf32>
 // CHECK:           }
 // CHECK:         }
 // CHECK:       }
-// CHECK:       dealloc [[BUFB]] : memref<128x128xf32>
-// CHECK:       dealloc [[BUFA]] : memref<128x128xf32>
+// CHECK:       memref.dealloc [[BUFB]] : memref<128x128xf32>
+// CHECK:       memref.dealloc [[BUFA]] : memref<128x128xf32>
 // CHECK:     }
 
 // Result matrix copy out.
 // CHECK:     affine.for %{{.*}} = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:       affine.for %{{.*}} = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
 // CHECK:         affine.load [[BUFC]][%{{.*}} - %{{.*}}, %{{.*}} - %{{.*}}] : memref<128x128xf32>
 // CHECK:         store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
 // CHECK:       }
 // CHECK:     }
-// CHECK:     dealloc [[BUFC]] : memref<128x128xf32>
+// CHECK:     memref.dealloc [[BUFC]] : memref<128x128xf32>
 // CHECK:   }
 // CHECK: }
 
 // Check that only one memref is copied when memref filter is used.
 
 //      FILTER: affine.for %{{.*}} = 0 to 4096 step 128 {
-//      FILTER:   alloc() : memref<128x4096xf32>
-//  FILTER-NOT:   alloc()
+//      FILTER:   memref.alloc() : memref<128x4096xf32>
+//  FILTER-NOT:   memref.alloc()
 //      FILTER:   affine.for
 //      FILTER:     affine.for %{{.*}} = 0 to 4096 {
 //      FILTER:   affine.for %{{.*}} = 0 to 4096 step 128 {
 // FILTER-NEXT:     affine.for %{{.*}} = 0 to 4096 step 128 {
 // FILTER-NEXT:       affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
 // FILTER-NEXT:         affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
 // FILTER-NEXT:           affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
-//      FILTER:   dealloc %{{.*}} : memref<128x4096xf32>
-//  FILTER-NOT:   dealloc %{{.*}} : memref<128x4096xf32>
+//      FILTER:   memref.dealloc %{{.*}} : memref<128x4096xf32>
+//  FILTER-NOT:   memref.dealloc %{{.*}} : memref<128x4096xf32>
 
 // -----
 
 //
 // This test case will lead to single element buffers. These are eventually
 // expected to be turned into registers via alloca and mem2reg.
 //
 // CHECK-SMALL-LABEL: func @single_elt_buffers
affine.for %j = 0 to 1024 {
         affine.store %9, %arg2[%i, %j] : memref<1024x1024xf32>
       }
     }
   }
   return %arg2 : memref<1024x1024xf32>
 }
 // CHECK-SMALL: affine.for %arg{{.*}} = 0 to 1024 {
 // CHECK-SMALL:   affine.for %arg{{.*}} = 0 to 1024 {
-// CHECK-SMALL:     alloc() : memref<1x1xf32>
+// CHECK-SMALL:     memref.alloc() : memref<1x1xf32>
 // CHECK-SMALL:     affine.load %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
 // CHECK-SMALL:     affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
 // CHECK-SMALL:     affine.for %arg{{.*}} = 0 to 1024 {
-// CHECK-SMALL:       alloc() : memref<1x1xf32>
+// CHECK-SMALL:       memref.alloc() : memref<1x1xf32>
 // CHECK-SMALL:       affine.load %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
 // CHECK-SMALL:       affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
 // CHECK-SMALL:       affine.load %{{.*}}[0, 0] : memref<1x1xf32>
 // CHECK-SMALL:       affine.load %{{.*}}[0, 0] : memref<1x1xf32>
 // CHECK-SMALL:       addf %{{.*}}, %{{.*}} : f32
 // CHECK-SMALL:       affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
-// CHECK-SMALL:       dealloc %{{.*}} : memref<1x1xf32>
+// CHECK-SMALL:       memref.dealloc %{{.*}} : memref<1x1xf32>
 // CHECK-SMALL:     }
 // CHECK-SMALL:     affine.load %{{.*}}[0, 0] : memref<1x1xf32>
 // CHECK-SMALL:     affine.store %{{.*}}, %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
-// CHECK-SMALL:     dealloc %{{.*}} : memref<1x1xf32>
+// CHECK-SMALL:     memref.dealloc %{{.*}} : memref<1x1xf32>
 // CHECK-SMALL:   }
 // CHECK-SMALL: }
 // CHECK-SMALL: return
 
 // Check that only one memref is copied when memref filter is used.
 
-//      FILTER: alloc() : memref<1024x1024xf32>
-//  FILTER-NOT: alloc()
+//      FILTER: memref.alloc() : memref<1024x1024xf32>
+//  FILTER-NOT: memref.alloc()
 //      FILTER: affine.for %{{.*}} = 0 to 1024 {
 //      FILTER:   affine.for %{{.*}} = 0 to 1024 {
 //      FILTER: affine.for %{{.*}} = 0 to 1024 {
 // FILTER-NEXT:   affine.for %{{.*}} = 0 to 1024 {
 // FILTER-NEXT:     affine.for %{{.*}} = 0 to 1024 {
-//      FILTER: dealloc %{{.*}} : memref<1024x1024xf32>
-//  FILTER-NOT: dealloc
+//      FILTER: memref.dealloc %{{.*}} : memref<1024x1024xf32>
+//  FILTER-NOT: memref.dealloc
 //  FILTER:     return
 
 // CHeck that only one memref is copied, because for-memref-region is enabled
 // (and the first ever encountered load is analyzed).
-//      MEMREF_REGION: alloc() : memref<1024x1024xf32>
-//  MEMREF_REGION-NOT: alloc()
+//      MEMREF_REGION: memref.alloc() : memref<1024x1024xf32>
+//  MEMREF_REGION-NOT: memref.alloc()
 //      MEMREF_REGION: affine.for %{{.*}} = 0 to 1024 {
 //      MEMREF_REGION:   affine.for %{{.*}} = 0 to 1024 {
 //      MEMREF_REGION:   }
 //      MEMREF_REGION: }
 // MEMREF_REGION-NEXT: affine.for %{{.*}} = 0 to 1024 {
 // MEMREF_REGION-NEXT:   affine.for %{{.*}} = 0 to 1024 {
 // MEMREF_REGION-NEXT:     affine.for %{{.*}} = 0 to 1024 {
-//      MEMREF_REGION: dealloc %{{.*}} : memref<1024x1024xf32>
-// MEMREF_REGION-NOT: dealloc
+//      MEMREF_REGION: memref.dealloc %{{.*}} : memref<1024x1024xf32>
+// MEMREF_REGION-NOT: memref.dealloc
 // MEMREF_REGION-NEXT: return
 
 // -----
 
 // This pattern typically appears with tiling with tile sizes that don't divide
 // the loop trip counts.
 
 #map_ub = affine_map<(d0) -> (4096, d0 + 100)>
affine.for %ii = affine_map<(d0) -> (d0)>(%i) to min #map_ub(%i) {
       %5 = affine.load %A[%ii] : memref<4096xf32>
       %6 = mulf %5, %5 : f32
       affine.store %6, %A[%ii] : memref<4096xf32>
     }
   }
   return %A : memref<4096xf32>
 }
 // CHECK:      affine.for %[[IV1:.*]] = 0 to 4096 step 100
-// CHECK:        %[[BUF:.*]] = alloc() : memref<100xf32>
+// CHECK:        %[[BUF:.*]] = memref.alloc() : memref<100xf32>
 // CHECK-NEXT:   affine.for %[[IV2:.*]] = #[[$MAP_IDENTITY]](%[[IV1]]) to min #[[$MAP_MIN_UB1]](%[[IV1]]) {
 // CHECK-NEXT:     affine.load %{{.*}}[%[[IV2]]] : memref<4096xf32>
 // CHECK-NEXT:     affine.store %{{.*}}, %[[BUF]][%[[IV2]] - %[[IV1]]] : memref<100xf32>
 // CHECK-NEXT:   }
 // CHECK-NEXT:   affine.for %[[IV2:.*]] = #[[$MAP_IDENTITY]](%[[IV1]]) to min #[[$MAP_MIN_UB2]](%[[IV1]]) {
 // CHECK-NEXT:     affine.load %[[BUF]][-%[[IV1]] + %[[IV2]]] : memref<100xf32>
 // CHECK-NEXT:     mulf
 // CHECK-NEXT:     affine.store %{{.*}}, %[[BUF]][-%[[IV1]] + %[[IV2]]] : memref<100xf32>
 // CHECK-NEXT:   }
 // CHECK:        affine.for %[[IV2:.*]] = #[[$MAP_IDENTITY]](%[[IV1]]) to min #[[$MAP_MIN_UB1]](%[[IV1]]) {
 // CHECK-NEXT:     affine.load %[[BUF]][%[[IV2]] - %[[IV1]]] : memref<100xf32>
 // CHECK-NEXT:     affine.store %{{.*}}, %{{.*}}[%[[IV2]]] : memref<4096xf32>
 // CHECK-NEXT:   }
-// CHECK-NEXT:   dealloc %[[BUF]] : memref<100xf32>
+// CHECK-NEXT:   memref.dealloc %[[BUF]] : memref<100xf32>
 // CHECK-NEXT: }
 
 // -----
 
 // Lower bound is a max; upper bound is a min. This pattern typically appears
 // with multi-level tiling when the tile sizes used don't divide loop trip
 // counts.
 
func @max_lower_bound(%M: memref<2048x516xf64>, %i : index, %j : index) {
   affine.for %ii = 0 to 2048 {
     affine.for %jj = max #lb()[%i, %j] to min #ub()[%i, %j] {
       affine.load %M[%ii, %jj] : memref<2048x516xf64>
     }
   }
   return
 }
 
-// CHECK:      %[[BUF:.*]] = alloc() : memref<2048x6xf64>
+// CHECK:      %[[BUF:.*]] = memref.alloc() : memref<2048x6xf64>
 // CHECK-NEXT: affine.for %[[ii:.*]] = 0 to 2048 {
 // CHECK-NEXT:   affine.for %[[jj:.*]] = max #[[$LB]]()[%[[i]], %[[j]]] to min #[[$UB]]()[%[[i]], %[[j]]] {
 // CHECK-NEXT:      affine.load %{{.*}}[%[[ii]], %[[jj]]] : memref<2048x516xf64>
 // CHECK-NEXT:      affine.store %{{.*}}, %[[BUF]][%[[ii]], %[[jj]] - symbol(%[[j]]) * 6] : memref<2048x6xf64>
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 // CHECK-NEXT: affine.for %[[ii_:.*]] = 0 to 2048 {
 // CHECK-NEXT:   affine.for %[[jj_:.*]] = max #[[$LB]]()[%{{.*}}, %{{.*}}] to min #[[$UB]]()[%{{.*}}, %{{.*}}] {
 // CHECK-NEXT:     affine.load %[[BUF]][%[[ii_]], %[[jj_]] - symbol(%[[j]]) * 6] : memref<2048x6xf64>
 // CHECK-NEXT:    }
 // CHECK-NEXT: }
-// CHECK-NEXT: dealloc %[[BUF]] : memref<2048x6xf64>
+// CHECK-NEXT: memref.dealloc %[[BUF]] : memref<2048x6xf64>

mlir/test/Dialect/Affine/affine-loop-invariant-code-motion.mlir

 // RUN: mlir-opt %s -affine-loop-invariant-code-motion -split-input-file | FileCheck %s
 
 func @nested_loops_both_having_invariant_code() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       affine.store %v0, %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
 
   return
 }
 
 // -----
 
 // The store-load forwarding can see through affine apply's since it relies on
 // dependence information.
 // CHECK-LABEL: func @store_affine_apply
 func @store_affine_apply() -> memref<10xf32> {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %arg0 = 0 to 10 {
       %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
       affine.store %cf7, %m[%t0] : memref<10xf32>
   }
   return %m : memref<10xf32>
 // CHECK:       %cst = constant 7.000000e+00 : f32
-// CHECK-NEXT:  %0 = alloc() : memref<10xf32>
+// CHECK-NEXT:  %0 = memref.alloc() : memref<10xf32>
 // CHECK-NEXT:  affine.for %arg0 = 0 to 10 {
 // CHECK-NEXT:      %1 = affine.apply #map{{[0-9]*}}(%arg0)
 // CHECK-NEXT:      affine.store %cst, %0[%1] : memref<10xf32>
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %0 : memref<10xf32>
 }
 
 // -----
 
 func @nested_loops_code_invariant_to_both() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       %v0 = addf %cf7, %cf8 : f32
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
 
   return
 }
 
 // -----
 
 func @single_loop_nothing_invariant() {
-  %m1 = alloc() : memref<10xf32>
-  %m2 = alloc() : memref<10xf32>
+  %m1 = memref.alloc() : memref<10xf32>
+  %m2 = memref.alloc() : memref<10xf32>
   affine.for %arg0 = 0 to 10 {
     %v0 = affine.load %m1[%arg0] : memref<10xf32>
     %v1 = affine.load %m2[%arg0] : memref<10xf32>
     %v2 = addf %v0, %v1 : f32
     affine.store %v2, %m1[%arg0] : memref<10xf32>
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
-  // CHECK-NEXT: %1 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
+  // CHECK-NEXT: %1 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: %3 = affine.load %1[%arg0] : memref<10xf32>
   // CHECK-NEXT: %4 = addf %2, %3 : f32
   // CHECK-NEXT: affine.store %4, %0[%arg0] : memref<10xf32>
 
   return
 }
 
 // -----
 
 func @invariant_code_inside_affine_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
     affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         %cf9 = addf %cf8, %cf8 : f32
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %1 = affine.apply #map{{[0-9]*}}(%arg0)
   // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @dependent_stores() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       %v1 = addf %cf7, %cf7 : f32
       affine.store %v1, %m[%arg1] : memref<10xf32>
       affine.store %v0, %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
 
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT:   affine.store %2, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT:   affine.store %1, %0[%arg0] : memref<10xf32>
 
   return
 }
 
 // -----
 
 func @independent_stores() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       %v1 = addf %cf7, %cf7 : f32
       affine.store %v0, %m[%arg0] : memref<10xf32>
       affine.store %v1, %m[%arg1] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT:   affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT:     affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT:     affine.store %2, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT:    }
 
   return
 }
 
 // -----
 
 func @load_dependent_store() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       %v1 = addf %cf7, %cf7 : f32
       affine.store %v0, %m[%arg1] : memref<10xf32>
       %v2 = affine.load %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT:   affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT:   %3 = affine.load %0[%arg0] : memref<10xf32>
 
   return
 }
 
 // -----
 
 func @load_after_load() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       %v1 = addf %cf7, %cf7 : f32
       %v3 = affine.load %m[%arg1] : memref<10xf32>
       %v2 = affine.load %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT: %4 = affine.load %0[%arg1] : memref<10xf32>
 
   return
 }
 
 // -----
 
 func @invariant_affine_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
 
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_if2() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg1] : memref<10xf32>
 
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if_else() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m[%arg0] : memref<10xf32>
           } else {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: } else {
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if_else2() {
-  %m = alloc() : memref<10xf32>
-  %m2 = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
+  %m2 = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           %tload1 = affine.load %m[%arg0] : memref<10xf32>
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m2[%arg0] : memref<10xf32>
           } else {
             %tload2 = affine.load %m[%arg0] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
-  // CHECK-NEXT: %1 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
+  // CHECK-NEXT: %1 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %2, %1[%arg0] : memref<10xf32>
   // CHECK-NEXT: } else {
   // CHECK-NEXT: %4 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if2() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           %v1 = affine.load %m[%arg0] : memref<10xf32>
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %v2 = affine.load %m[%arg0] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_for_inside_affine_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
           affine.for %arg2 = 0 to 10 {
             affine.store %cf9, %m[%arg2] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.for %arg2 = 0 to 10 {
   // CHECK-NEXT: affine.store %1, %0[%arg2] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_constant_and_load() {
-  %m = alloc() : memref<100xf32>
-  %m2 = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
+  %m2 = memref.alloc() : memref<100xf32>
   affine.for %arg0 = 0 to 5 {
     %c0 = constant 0 : index
     %v = affine.load %m2[%c0] : memref<100xf32>
     affine.store %v, %m[%arg0] : memref<100xf32>
   }
 
-  // CHECK: %0 = alloc() : memref<100xf32>
-  // CHECK-NEXT: %1 = alloc() : memref<100xf32>
+  // CHECK: %0 = memref.alloc() : memref<100xf32>
+  // CHECK-NEXT: %1 = memref.alloc() : memref<100xf32>
   // CHECK-NEXT: %c0 = constant 0 : index
   // CHECK-NEXT: %2 = affine.load %1[%c0] : memref<100xf32>
   // CHECK-NEXT: affine.for %arg0 = 0 to 5 {
   // CHECK-NEXT:  affine.store %2, %0[%arg0] : memref<100xf32>
 
 
   return
 }
 
 // -----
 
 func @nested_load_store_same_memref() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cst = constant 8.0 : f32
   %c0 = constant 0 : index
    affine.for %arg0 = 0 to 10 {
     %v0 = affine.load %m[%c0] : memref<10xf32>
     affine.for %arg1 = 0 to 10 {
       affine.store %cst, %m[%arg1] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: %c0 = constant 0 : index
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT:  %1 = affine.load %0[%c0] : memref<10xf32>
   // CHECK-NEXT:   affine.for %arg1 = 0 to 10 {
   // CHECK-NEXT:    affine.store %cst, %0[%arg1] : memref<10xf32>
 
 
   return
 }
 
 // -----
 
 func @nested_load_store_same_memref2() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cst = constant 8.0 : f32
   %c0 = constant 0 : index
    affine.for %arg0 = 0 to 10 {
      affine.store %cst, %m[%c0] : memref<10xf32>
       affine.for %arg1 = 0 to 10 {
         %v0 = affine.load %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: %c0 = constant 0 : index
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT:   affine.store %cst, %0[%c0] : memref<10xf32>
   // CHECK-NEXT:   %1 = affine.load %0[%arg0] : memref<10xf32>
 
 
   return
 }
 
 // -----
 
 // CHECK-LABEL:   func @do_not_hoist_dependent_side_effect_free_op
 func @do_not_hoist_dependent_side_effect_free_op(%arg0: memref<10x512xf32>) {
-  %0 = alloca() : memref<1xf32>
+  %0 = memref.alloca() : memref<1xf32>
   %cst = constant 8.0 : f32
   affine.for %i = 0 to 512 {
     affine.for %j = 0 to 10 {
       %5 = affine.load %arg0[%i, %j] : memref<10x512xf32>
       %6 = affine.load %0[0] : memref<1xf32>
       %add = addf %5, %6 : f32
       affine.store %add, %0[0] : memref<1xf32>
     }

 // CHECK-NEXT:    affine.load
 // CHECK-NEXT:    mulf
 // CHECK-NEXT:  }
 
 // -----
 
 // CHECK-LABEL: func @vector_loop_nothing_invariant
 func @vector_loop_nothing_invariant() {
-  %m1 = alloc() : memref<40xf32>
-  %m2 = alloc() : memref<40xf32>
+  %m1 = memref.alloc() : memref<40xf32>
+  %m2 = memref.alloc() : memref<40xf32>
   affine.for %arg0 = 0 to 10 {
     %v0 = affine.vector_load %m1[%arg0*4] : memref<40xf32>, vector<4xf32>
     %v1 = affine.vector_load %m2[%arg0*4] : memref<40xf32>, vector<4xf32>
     %v2 = addf %v0, %v1 : vector<4xf32>
     affine.vector_store %v2, %m1[%arg0*4] : memref<40xf32>, vector<4xf32>
   }
   return
 }
 
 // CHECK:       affine.for
 // CHECK-NEXT:    affine.vector_load
 // CHECK-NEXT:    affine.vector_load
 // CHECK-NEXT:    addf
 // CHECK-NEXT:    affine.vector_store
 // CHECK-NEXT:  }
 
 // -----
 
 // CHECK-LABEL: func @vector_loop_all_invariant
 func @vector_loop_all_invariant() {
-  %m1 = alloc() : memref<4xf32>
-  %m2 = alloc() : memref<4xf32>
-  %m3 = alloc() : memref<4xf32>
+  %m1 = memref.alloc() : memref<4xf32>
+  %m2 = memref.alloc() : memref<4xf32>
+  %m3 = memref.alloc() : memref<4xf32>
   affine.for %arg0 = 0 to 10 {
     %v0 = affine.vector_load %m1[0] : memref<4xf32>, vector<4xf32>
     %v1 = affine.vector_load %m2[0] : memref<4xf32>, vector<4xf32>
     %v2 = addf %v0, %v1 : vector<4xf32>
     affine.vector_store %v2, %m3[0] : memref<4xf32>, vector<4xf32>
   }
   return
 }
 
-// CHECK:       alloc()
-// CHECK-NEXT:  alloc()
-// CHECK-NEXT:  alloc()
+// CHECK:       memref.alloc()
+// CHECK-NEXT:  memref.alloc()
+// CHECK-NEXT:  memref.alloc()
 // CHECK-NEXT:  affine.vector_load
 // CHECK-NEXT:  affine.vector_load
 // CHECK-NEXT:  addf
 // CHECK-NEXT:  affine.vector_store
 // CHECK-NEXT:  affine.for

mlir/test/Dialect/Affine/affine-loop-normalize.mlir

 // RUN: mlir-opt %s -affine-loop-normalize -split-input-file | FileCheck %s
 
 // Normalize steps to 1 and lower bounds to 0.
 
 // CHECK-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 * 3)>
 // CHECK-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 * 2 + 1)>
 // CHECK-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
 
 // CHECK-LABEL: func @normalize_parallel()
 func @normalize_parallel() {
   %cst = constant 1.0 : f32
-  %0 = alloc() : memref<2x4xf32>
+  %0 = memref.alloc() : memref<2x4xf32>
   // CHECK: affine.parallel (%[[i0:.*]], %[[j0:.*]]) = (0, 0) to (4, 2)
   affine.parallel (%i, %j) = (0, 1) to (10, 5) step (3, 2) {
     // CHECK: %[[i1:.*]] = affine.apply [[$MAP0]](%[[i0]])
     // CHECK: %[[j1:.*]] = affine.apply [[$MAP1]](%[[j0]])
     // CHECK: affine.parallel (%[[k0:.*]]) = (0) to (%[[j1]] - %[[i1]])
     affine.parallel (%k) = (%i) to (%j) {
       // CHECK: %[[k1:.*]] = affine.apply [[$MAP2]](%[[i1]], %[[k0]])
       // CHECK: affine.store %{{.*}}, %{{.*}}[%[[i1]], %[[k1]]] : memref<2x4xf32>

mlir/test/Dialect/Affine/canonicalize.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s
 
 // -----
 
 // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0) -> (d0 - 1)>
 // CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0) -> (d0 + 1)>
 
 // CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() {
 func @compose_affine_maps_1dto2d_no_symbols() {
-  %0 = alloc() : memref<4x4xf32>
+  %0 = memref.alloc() : memref<4x4xf32>
 
   affine.for %i0 = 0 to 15 {
     // Test load[%x, %x]
 
     %x0 = affine.apply affine_map<(d0) -> (d0 - 1)> (%i0)
     %x1_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%x0, %x0)
     %x1_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%x0, %x0)
 
     // CHECK: %[[I0A:.*]] = affine.apply #[[$MAP0]](%{{.*}})
     // CHECK-NEXT: %[[V0:.*]] = load %0[%[[I0A]], %[[I0A]]]
     %v0 = load %0[%x1_0, %x1_1] : memref<4x4xf32>
 
     // Test store[%y, %y]
     %y0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
     %y1_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%y0, %y0)
     %y1_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %y0)
 
     // CHECK-NEXT: %[[I1A:.*]] = affine.apply #[[$MAP1]](%{{.*}})
-    // CHECK-NEXT: store %[[V0]], %0[%[[I1A]], %[[I1A]]]
-    store %v0, %0[%y1_0, %y1_1] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %0[%[[I1A]], %[[I1A]]]
+    memref.store %v0, %0[%y1_0, %y1_1] : memref<4x4xf32>
 
     // Test store[%x, %y]
     %xy_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%x0, %y0)
     %xy_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%x0, %y0)
 
-    // CHECK-NEXT: store %[[V0]], %0[%[[I0A]], %[[I1A]]]
-    store %v0, %0[%xy_0, %xy_1] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %0[%[[I0A]], %[[I1A]]]
+    memref.store %v0, %0[%xy_0, %xy_1] : memref<4x4xf32>
 
     // Test store[%y, %x]
     %yx_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%y0, %x0)
     %yx_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %x0)
-    // CHECK-NEXT: store %[[V0]], %0[%[[I1A]], %[[I0A]]]
-    store %v0, %0[%yx_0, %yx_1] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %0[%[[I1A]], %[[I0A]]]
+    memref.store %v0, %0[%yx_0, %yx_1] : memref<4x4xf32>
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP4:.*]] = affine_map<(d0) -> (d0 - 4)>
 // CHECK-DAG: #[[$MAP7:.*]] = affine_map<(d0) -> (d0 * 2 - 3)>
 // CHECK-DAG: #[[$MAP7a:.*]] = affine_map<(d0) -> (d0 * 2 + 1)>
 
 // CHECK-LABEL: func @compose_affine_maps_1dto2d_with_symbols() {
 func @compose_affine_maps_1dto2d_with_symbols() {
-  %0 = alloc() : memref<4x4xf32>
+  %0 = memref.alloc() : memref<4x4xf32>
 
   affine.for %i0 = 0 to 15 {
     // Test load[%x0, %x0] with symbol %c4
     %c4 = constant 4 : index
     %x0 = affine.apply affine_map<(d0)[s0] -> (d0 - s0)> (%i0)[%c4]
 
     // CHECK: %[[I0:.*]] = affine.apply #[[$MAP4]](%{{.*}})
     // CHECK-NEXT: %[[V0:.*]] = load %{{.*}}[%[[I0]], %[[I0]]]
     %v0 = load %0[%x0, %x0] : memref<4x4xf32>
 
     // Test load[%x0, %x1] with symbol %c4 captured by '%x0' map.
     %x1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
     %y1 = affine.apply affine_map<(d0, d1) -> (d0+d1)> (%x0, %x1)
     // CHECK-NEXT: %[[I1:.*]] = affine.apply #[[$MAP7]](%{{.*}})
-    // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I1]], %[[I1]]]
-    store %v0, %0[%y1, %y1] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I1]], %[[I1]]]
+    memref.store %v0, %0[%y1, %y1] : memref<4x4xf32>
 
     // Test store[%x1, %x0] with symbol %c4 captured by '%x0' map.
     %y2 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x1, %x0)
     // CHECK-NEXT: %[[I2:.*]] = affine.apply #[[$MAP7]](%{{.*}})
-    // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I2]], %[[I2]]]
-    store %v0, %0[%y2, %y2] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I2]], %[[I2]]]
+    memref.store %v0, %0[%y2, %y2] : memref<4x4xf32>
 
     // Test store[%x2, %x0] with symbol %c4 from '%x0' and %c5 from '%x2'
     %c5 = constant 5 : index
     %x2 = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i0)[%c5]
     %y3 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x2, %x0)
     // CHECK: %[[I3:.*]] = affine.apply #[[$MAP7a]](%{{.*}})
-    // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I3]], %[[I3]]]
-    store %v0, %0[%y3, %y3] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I3]], %[[I3]]]
+    memref.store %v0, %0[%y3, %y3] : memref<4x4xf32>
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP8:.*]] = affine_map<(d0, d1) -> (d1 + (d0 ceildiv 4) * 4 - (d1 floordiv 4) * 4)>
 // CHECK-DAG: #[[$MAP8a:.*]] = affine_map<(d0, d1) -> (d1 + (d0 ceildiv 8) * 8 - (d1 floordiv 8) * 8)>
 
 // CHECK-LABEL: func @compose_affine_maps_2d_tile() {
 func @compose_affine_maps_2d_tile() {
-  %0 = alloc() : memref<16x32xf32>
-  %1 = alloc() : memref<16x32xf32>
+  %0 = memref.alloc() : memref<16x32xf32>
+  %1 = memref.alloc() : memref<16x32xf32>
 
   %c4 = constant 4 : index
   %c8 = constant 8 : index
 
   affine.for %i0 = 0 to 3 {
     %x0 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i0)[%c4]
     affine.for %i1 = 0 to 3 {
       %x1 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i1)[%c8]
       affine.for %i2 = 0 to 3 {
         %x2 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i2)[%c4]
         affine.for %i3 = 0 to 3 {
           %x3 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i3)[%c8]
 
           %x40 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] ->
             ((d0 * s0) + d2)> (%x0, %x1, %x2, %x3)[%c4, %c8]
           %x41 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] ->
             ((d1 * s1) + d3)> (%x0, %x1, %x2, %x3)[%c4, %c8]
           // CHECK: %[[I0:.*]] = affine.apply #[[$MAP8]](%{{.*}}, %{{.*}})
           // CHECK: %[[I1:.*]] = affine.apply #[[$MAP8a]](%{{.*}}, %{{.*}})
           // CHECK-NEXT: %[[L0:.*]] = load %{{.*}}[%[[I0]], %[[I1]]]
           %v0 = load %0[%x40, %x41] : memref<16x32xf32>
 
-          // CHECK-NEXT: store %[[L0]], %{{.*}}[%[[I0]], %[[I1]]]
-          store %v0, %1[%x40, %x41] : memref<16x32xf32>
+          // CHECK-NEXT: memref.store %[[L0]], %{{.*}}[%[[I0]], %[[I1]]]
+          memref.store %v0, %1[%x40, %x41] : memref<16x32xf32>
         }
       }
     }
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP4b:.*]] = affine_map<(d0) -> (d0 - 7)>
 // CHECK-DAG: #[[$MAP9:.*]] = affine_map<(d0) -> (d0 + 3)>
 // CHECK-DAG: #[[$MAP10:.*]] = affine_map<(d0) -> (d0 * 3)>
 // CHECK-DAG: #[[$MAP11:.*]] = affine_map<(d0) -> ((d0 + 3) ceildiv 3)>
 // CHECK-DAG: #[[$MAP12:.*]] = affine_map<(d0) -> (d0 * 7 - 49)>
 
 // CHECK-LABEL: func @compose_affine_maps_dependent_loads() {
 func @compose_affine_maps_dependent_loads() {
-  %0 = alloc() : memref<16x32xf32>
-  %1 = alloc() : memref<16x32xf32>
+  %0 = memref.alloc() : memref<16x32xf32>
+  %1 = memref.alloc() : memref<16x32xf32>
 
   affine.for %i0 = 0 to 3 {
     affine.for %i1 = 0 to 3 {
       affine.for %i2 = 0 to 3 {
         %c3 = constant 3 : index
         %c7 = constant 7 : index
 
         %x00 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0)>
             (%i0, %i1, %i2)[%c3, %c7]
         %x01 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d1 - s1)>
             (%i0, %i1, %i2)[%c3, %c7]
         %x02 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d2 * s0)>
             (%i0, %i1, %i2)[%c3, %c7]
 
         // CHECK: %[[I0:.*]] = affine.apply #[[$MAP9]](%{{.*}})
         // CHECK: %[[I1:.*]] = affine.apply #[[$MAP4b]](%{{.*}})
         // CHECK: %[[I2:.*]] = affine.apply #[[$MAP10]](%{{.*}})
         // CHECK-NEXT: %[[V0:.*]] = load %{{.*}}[%[[I0]], %[[I1]]]
         %v0 = load %0[%x00, %x01] : memref<16x32xf32>
 
-        // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I0]], %[[I2]]]
-        store %v0, %0[%x00, %x02] : memref<16x32xf32>
+        // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I0]], %[[I2]]]
+        memref.store %v0, %0[%x00, %x02] : memref<16x32xf32>
 
         // Swizzle %i0, %i1
-        // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I1]], %[[I0]]]
-        store %v0, %0[%x01, %x00] : memref<16x32xf32>
+        // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I1]], %[[I0]]]
+        memref.store %v0, %0[%x01, %x00] : memref<16x32xf32>
 
         // Swizzle %x00, %x01 and %c3, %c7
         %x10 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 * s1)>
            (%x01, %x00)[%c3, %c7]
         %x11 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 ceildiv s0)>
            (%x01, %x00)[%c3, %c7]
 
         // CHECK-NEXT: %[[I2A:.*]] = affine.apply #[[$MAP12]](%{{.*}})
         // CHECK-NEXT: %[[I2B:.*]] = affine.apply #[[$MAP11]](%{{.*}})
-        // CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I2A]], %[[I2B]]]
-        store %v0, %0[%x10, %x11] : memref<16x32xf32>
+        // CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I2A]], %[[I2B]]]
+        memref.store %v0, %0[%x10, %x11] : memref<16x32xf32>
       }
     }
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP13A:.*]] = affine_map<(d0) -> ((d0 + 6) ceildiv 8)>
 // CHECK-DAG: #[[$MAP13B:.*]] = affine_map<(d0) -> ((d0 * 4 - 4) floordiv 3)>
 
 // CHECK-LABEL: func @compose_affine_maps_diamond_dependency
 func @compose_affine_maps_diamond_dependency(%arg0: f32, %arg1: memref<4x4xf32>) {
   affine.for %i0 = 0 to 15 {
     %a = affine.apply affine_map<(d0) -> (d0 - 1)> (%i0)
     %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
     %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
     %d0 = affine.apply affine_map<(d0, d1) -> (d0 ceildiv 8)> (%b, %c)
     %d1 = affine.apply affine_map<(d0, d1) -> (d1 floordiv 3)> (%b, %c)
     // CHECK: %[[I0:.*]] = affine.apply #[[$MAP13A]](%{{.*}})
     // CHECK: %[[I1:.*]] = affine.apply #[[$MAP13B]](%{{.*}})
-    // CHECK-NEXT: store %arg0, %arg1[%[[I0]], %[[I1]]]
-    store %arg0, %arg1[%d0, %d1] : memref<4x4xf32>
+    // CHECK-NEXT: memref.store %arg0, %arg1[%[[I0]], %[[I1]]]
+    memref.store %arg0, %arg1[%d0, %d1] : memref<4x4xf32>
   }
 
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP14:.*]] = affine_map<()[s0, s1] -> (((s1 + s0) * 4) floordiv s0)>
 
 // CHECK-LABEL: func @compose_affine_maps_multiple_symbols
 func @compose_affine_maps_multiple_symbols(%arg0: index, %arg1: index) -> index {
   %a = affine.apply affine_map<(d0)[s0] -> (s0 + d0)> (%arg0)[%arg1]
   %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
   %e = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%c)[%arg1]
   // CHECK: [[I0:.*]] = affine.apply #[[$MAP14]]()[%{{.*}}, %{{.*}}]
   return %e : index
 }
 
 // -----
 
 // CHECK-LABEL: func @arg_used_as_dim_and_symbol
 func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index, %arg2: f32) {
   %c9 = constant 9 : index
-  %1 = alloc() : memref<100x100xf32, 1>
-  %2 = alloc() : memref<1xi32>
+  %1 = memref.alloc() : memref<100x100xf32, 1>
+  %2 = memref.alloc() : memref<1xi32>
   affine.for %i0 = 0 to 100 {
     affine.for %i1 = 0 to 100 {
       %3 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 + s0 + s1)>
         (%i0, %i1)[%arg1, %c9]
       %4 = affine.apply affine_map<(d0, d1, d3) -> (d3 - (d0 + d1))>
         (%arg1, %c9, %3)
-      // CHECK: store %arg2, %{{.*}}[%{{.*}}, %{{.*}}]
-      store %arg2, %1[%4, %arg1] : memref<100x100xf32, 1>
+      // CHECK: memref.store %arg2, %{{.*}}[%{{.*}}, %{{.*}}]
+      memref.store %arg2, %1[%4, %arg1] : memref<100x100xf32, 1>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @trivial_maps
 func @trivial_maps() {
   // CHECK-NOT: affine.apply
 
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cst = constant 0.000000e+00 : f32
   affine.for %i1 = 0 to 10 {
     %1 = affine.apply affine_map<()[s0] -> (s0)>()[%c0]
-    store %cst, %0[%1] : memref<10xf32>
+    memref.store %cst, %0[%1] : memref<10xf32>
     %2 = load %0[%c0] : memref<10xf32>
 
     %3 = affine.apply affine_map<()[] -> (0)>()[]
-    store %cst, %0[%3] : memref<10xf32>
-    store %2, %0[%c0] : memref<10xf32>
+    memref.store %cst, %0[%3] : memref<10xf32>
+    memref.store %2, %0[%c0] : memref<10xf32>
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP15:.*]] = affine_map<()[s0] -> (s0 - 42)>
 

 
 // CHECK-LABEL: func @symbolic_semi_affine(%arg0: index, %arg1: index, %arg2: memref<?xf32>) {
 func @symbolic_semi_affine(%M: index, %N: index, %A: memref<?xf32>) {
   %f1 = constant 1.0 : f32
   affine.for %i0 = 1 to 100 {
     %1 = affine.apply affine_map<()[s0] -> (s0 + 1)> ()[%M]
     %2 = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%i0)[%1]
     // CHECK-DAG: {{.*}} = affine.apply #[[$symbolic_semi_affine]](%{{.*}})[%{{.*}}]
-    store %f1, %A[%2] : memref<?xf32>
+    memref.store %f1, %A[%2] : memref<?xf32>
   }
   return
 }
 
 // -----
 
 // CHECK: #[[$MAP0:.*]] = affine_map<()[s0] -> (0, s0)>
 // CHECK: #[[$MAP1:.*]] = affine_map<()[s0] -> (100, s0)>

 
 #map3 = affine_map<(d0) -> (d0 * 5)>
 
 // CHECK-LABEL: func @affine_parallel_const_bounds
 func @affine_parallel_const_bounds() {
   %cst = constant 1.0 : f32
   %c0 = constant 0 : index
   %c4 = constant 4 : index
-  %0 = alloc() : memref<4xf32>
+  %0 = memref.alloc() : memref<4xf32>
   // CHECK: affine.parallel (%{{.*}}) = (0) to (4)
   affine.parallel (%i) = (%c0) to (%c0 + %c4) {
     %1 = affine.apply #map3(%i)
     // CHECK: affine.parallel (%{{.*}}) = (0) to (%{{.*}} * 5)
     affine.parallel (%j) = (%c0) to (%1) {
       affine.store %cst, %0[%j] : memref<4xf32>
     }
   }
   return
 }
 
 // -----
 
 func @compose_affine_maps_div_symbol(%A : memref<i64>, %i0 : index, %i1 : index) {
   %0 = affine.apply affine_map<()[s0] -> (2 * s0)> ()[%i0]
   %1 = affine.apply affine_map<()[s0] -> (3 * s0)> ()[%i0]
   %2 = affine.apply affine_map<(d0)[s0, s1] -> (d0 mod s1 + s0 * s1 + s0 * 4)> (%i1)[%0, %1]
   %3 = index_cast %2: index to i64
-  store %3, %A[]: memref<i64>
+  memref.store %3, %A[]: memref<i64>
   affine.for %i2 = 0 to 3 {
     %4 = affine.apply affine_map<(d0)[s0, s1] -> (d0 ceildiv s1 + s0 + s0 * 3)> (%i2)[%0, %1]
     %5 = index_cast %4: index to i64
-    store %5, %A[]: memref<i64>
+    memref.store %5, %A[]: memref<i64>
   }
   return
 }

mlir/test/Dialect/Affine/dma-generate.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -affine-data-copy-generate="generate-dma fast-mem-space=2 skip-non-unit-stride-loops" -verify-diagnostics | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -affine-data-copy-generate="generate-dma fast-mem-capacity=16 fast-mem-space=2" | FileCheck %s --check-prefix FAST-MEM-16KB
 
 // We run most test cases with -copy-skip-non-unit-stride-loops to allow testing
 // DMA generation at inner levels easily - since the DMA generation would
 // otherwise always generate DMAs at the outermost level (default for fast mem
 // capacity is infinite). Using a specific capacity makes it harder to write
 // a test case as one would have to calculate total footprints. With
 // -copy-skip-non-unit-stride-loops, non-unit strides will always be skipped and
 // its inner loops will be traversed till a unit stride loop is found (or the
 // innermost block is reached).
 
 // -----
 
 // CHECK-LABEL: func @loop_nest_1d() {
 func @loop_nest_1d() {
-  %A = alloc() : memref<256 x f32>
-  %B = alloc() : memref<512 x f32>
-  %F = alloc() : memref<256 x f32, 2>
+  %A = memref.alloc() : memref<256 x f32>
+  %B = memref.alloc() : memref<512 x f32>
+  %F = memref.alloc() : memref<256 x f32, 2>
   // First DMA buffer.
-  // CHECK:  alloc() : memref<256xf32>
-  // CHECK:  alloc() : memref<256xf32, 2>
+  // CHECK:  memref.alloc() : memref<256xf32>
+  // CHECK:  memref.alloc() : memref<256xf32, 2>
   // Tag for first DMA.
-  // CHECK:  alloc() : memref<1xi32>
+  // CHECK:  memref.alloc() : memref<1xi32>
   // First DMA transfer.
   // CHECK:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
   // CHECK:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   // Second DMA buffer.
-  // CHECK:  alloc() : memref<256xf32, 2>
+  // CHECK:  memref.alloc() : memref<256xf32, 2>
   // Tag for second DMA.
-  // CHECK:  alloc() : memref<1xi32>
+  // CHECK:  memref.alloc() : memref<1xi32>
   // Second DMA transfer.
   // CHECK:       affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<512xf32>, memref<256xf32, 2>, memref<1xi32>
   // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   // CHECK: affine.for %[[IV:.*]] = 0 to 256 {
       // CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
       // Buffer for '%{{.*}}' in faster memref space is of smaller size: 256xf32
       // Affine map for load on B is composed and becomes identity.
       // CHECK:      affine.load %{{.*}}[%[[IV]]] : memref<256xf32, 2>
func @loop_nest_1d() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @loop_nest_high_d
 // CHECK:      %{{.*}} = constant 16384 : index
-// CHECK-DAG:  [[BUFB:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
-// CHECK-DAG:  [[BUFA:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
-// CHECK-DAG:  [[BUFC:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
-// CHECK-DAG:  [[TAGB:%[0-9]+]] = alloc() : memref<1xi32>
-// CHECK-DAG:  [[TAGA:%[0-9]+]] = alloc() : memref<1xi32>
-// CHECK-DAG:  [[TAGC:%[0-9]+]] = alloc() : memref<1xi32>
-// CHECK-DAG:  [[TAGC_W:%[0-9]+]] = alloc() : memref<1xi32>
+// CHECK-DAG:  [[BUFB:%[0-9]+]] = memref.alloc() : memref<512x32xf32, 2>
+// CHECK-DAG:  [[BUFA:%[0-9]+]] = memref.alloc() : memref<512x32xf32, 2>
+// CHECK-DAG:  [[BUFC:%[0-9]+]] = memref.alloc() : memref<512x32xf32, 2>
+// CHECK-DAG:  [[TAGB:%[0-9]+]] = memref.alloc() : memref<1xi32>
+// CHECK-DAG:  [[TAGA:%[0-9]+]] = memref.alloc() : memref<1xi32>
+// CHECK-DAG:  [[TAGC:%[0-9]+]] = memref.alloc() : memref<1xi32>
+// CHECK-DAG:  [[TAGC_W:%[0-9]+]] = memref.alloc() : memref<1xi32>
 // INCOMING DMA for B
 // CHECK-DAG:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFB]][%{{.*}}, %{{.*}}], [[TAGB]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
 // CHECK-DAG:  affine.dma_wait [[TAGB]][%{{.*}}], %{{.*}} : memref<1xi32>
 // INCOMING DMA for A.
 // CHECK-DAG:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFA]][%{{.*}}, %{{.*}}], [[TAGA]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
 // CHECK-DAG:  affine.dma_wait [[TAGA]][%{{.*}}], %{{.*}} : memref<1xi32>
 // INCOMING DMA for C.
 // CHECK-DAG:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFC]][%{{.*}}, %{{.*}}], [[TAGC]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>

 }
 
 // -----
 
 // A loop nest with a modulo 2 access. A strided DMA is not needed here a 1x2
 // region within a 256 x 8 memref.
 //
 // CHECK-LABEL: func @loop_nest_modulo() {
-// CHECK:       alloc() : memref<256x8xf32>
+// CHECK:       memref.alloc() : memref<256x8xf32>
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 32 step 4 {
-// CHECK:           alloc() : memref<1x2xf32, 2>
-// CHECK-NEXT:      alloc() : memref<1xi32>
+// CHECK:           memref.alloc() : memref<1x2xf32, 2>
+// CHECK-NEXT:      memref.alloc() : memref<1xi32>
 // Composition of the affine map for '%{{.*}}' causes '%{{.*}}' to be added as a symbol.
 // CHECK-NEXT:      affine.dma_start %{{.*}}[%{{.*}}, 0], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256x8xf32>, memref<1x2xf32, 2>, memref<1xi32>
 // CHECK-NEXT:      affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:      affine.for %{{.*}} = 0 to 8 {
 //                    ...
 //                    ...
 // CHECK:           }
 // CHECK-NEXT:      dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:      dealloc %{{.*}} : memref<1x2xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:    return
 func @loop_nest_modulo() {
-  %A = alloc() : memref<256 x 8 x f32>
+  %A = memref.alloc() : memref<256 x 8 x f32>
   affine.for %i = 0 to 32 step 4 {
     // DMAs will be performed at this level (%j is the first unit stride loop)
     affine.for %j = 0 to 8 {
       %idx = affine.apply affine_map<(d0) -> (d0 mod 2)> (%j)
       // A buffer of size 32 x 2 will be allocated (original buffer was 256 x 8).
       %v = affine.load %A[%i, %idx] : memref<256 x 8 x f32>
     }
   }
   return
 }
 
 // -----
 
 // DMA on tiled loop nest. This also tests the case where the bounds are
 // dependent on outer loop IVs.
 // CHECK-LABEL: func @loop_nest_tiled() -> memref<256x1024xf32> {
 func @loop_nest_tiled() -> memref<256x1024xf32> {
-  %0 = alloc() : memref<256x1024xf32>
+  %0 = memref.alloc() : memref<256x1024xf32>
   affine.for %i0 = 0 to 256 step 32 {
     affine.for %i1 = 0 to 1024 step 32 {
-// CHECK:      alloc() : memref<32x32xf32, 2>
-// CHECK-NEXT: alloc() : memref<1xi32>
+// CHECK:      memref.alloc() : memref<32x32xf32, 2>
+// CHECK-NEXT: memref.alloc() : memref<1xi32>
 // Strided DMA here: 32 x 32 tile in a 256 x 1024 memref.
 // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<256x1024xf32>, memref<32x32xf32, 2>, memref<1xi32>
 // CHECK-NEXT: affine.dma_wait
 // CHECK-NEXT: affine.for %{{.*}} = #map
 // CHECK-NEXT:   affine.for %{{.*}} = #map
       affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 32)>(%i0) {
         affine.for %i3 = affine_map<(d0) -> (d0)>(%i1) to affine_map<(d0) -> (d0 + 32)>(%i1) {
           // CHECK: affine.load %{{.*}}[-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<32x32xf32, 2>
           %1 = affine.load %0[%i2, %i3] : memref<256x1024xf32>
         } // CHECK-NEXT: }
       }
     }
   }
   return %0 : memref<256x1024xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dma_constant_dim_access
 func @dma_constant_dim_access(%A : memref<100x100xf32>) {
   %one = constant 1 : index
   %N = constant 100 : index
-  // CHECK:      alloc() : memref<1x100xf32, 2>
-  // CHECK-NEXT: alloc() : memref<1xi32>
+  // CHECK:      memref.alloc() : memref<1x100xf32, 2>
+  // CHECK-NEXT: memref.alloc() : memref<1xi32>
   // No strided DMA needed here.
   // CHECK:      affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}  : memref<100x100xf32>, memref<1x100xf32, 2>,
   // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   affine.for %i = 0 to 100 {
     affine.for %j = 0 to affine_map<()[s0] -> (s0)> ()[%N] {
       // CHECK: affine.load %{{.*}}[0, %{{.*}}] : memref<1x100xf32, 2>
       affine.load %A[%one, %j] : memref<100 x 100 x f32>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @dma_with_symbolic_accesses
 func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
   %N = constant 9 : index
   affine.for %i = 0 to 100 {
     affine.for %j = 0 to 100 {
       %idy = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 + s0 + s1)>(%i, %j)[%M, %N]
       affine.load %A[%i, %idy] : memref<100 x 100 x f32>
     }
   }
   return
-// CHECK:       alloc() : memref<100x100xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<100x100xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[0, symbol(%{{.*}}) + 9], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}}
 // CHECK-NEXT:  affine.for %[[IV0:.*]] = 0 to 100 {
 // CHECK-NEXT:    affine.for %[[IV1:.*]] = 0 to 100 {
 // CHECK:           affine.load %{{.*}}[%[[IV0]], %[[IV1]]] : memref<100x100xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK:       return
 }
 
 // -----
 
 // CHECK-LABEL: func @dma_with_symbolic_loop_bounds
 func @dma_with_symbolic_loop_bounds(%A : memref<100x100xf32>, %M : index, %N: index) {
   %K = constant 9 : index
 // The buffer size can't be bound by a constant smaller than the original
 // memref size; so the DMA buffer is the entire 100x100.
-// CHECK:       alloc() : memref<100x100xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<100x100xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   affine.for %i = 0 to 100 {
     affine.for %j = %M to %N {
       %idy = affine.apply affine_map<(d1) [s0] -> (d1 + s0)>(%j)[%K]
       affine.load %A[%i, %idy] : memref<100 x 100 x f32>
     }
   }

 // The second load accesses ([64,320), [2,258))
 // The first store writes to ([2,258), [192,448))
 // The second store writes to ([128,320), [2,258))
 // The union of all these regions is of size 318 x 446 and has its origin at (2,
 // 2), i.e., the window ([2,320), [2,448)) in the original space.
 
 // CHECK-LABEL: func @multi_load_store_union() {
 func @multi_load_store_union() {
-  %A = alloc() : memref<512 x 512 x f32>
+  %A = memref.alloc() : memref<512 x 512 x f32>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       %idx = affine.apply affine_map<(d0) -> (d0 + 64)>(%i)
       %idy = affine.apply affine_map<(d0) -> (d0 + 128)>(%j)
       %ishift = affine.apply affine_map<(d0) -> (d0 + 2)>(%i)
       %jshift = affine.apply affine_map<(d0) -> (d0 + 2)>(%j)
 
       %u = affine.load %A[%ishift, %idy] : memref<512 x 512 x f32>
       %v = affine.load %A[%idx, %jshift] : memref<512 x 512 x f32>
 
       %sidx = affine.apply affine_map<(d0) -> (d0 + 128)>(%i)
       %sidy = affine.apply affine_map<(d0) -> (d0 + 192)>(%j)
 
       affine.store %u, %A[%ishift, %sidy] : memref<512 x 512 x f32>
       affine.store %v, %A[%sidx, %jshift] : memref<512 x 512 x f32>
     }
   }
   return
 }
-// CHECK:       alloc() : memref<512x512xf32>
-// CHECK-NEXT:  alloc() : memref<382x446xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<512x512xf32>
+// CHECK-NEXT:  memref.alloc() : memref<382x446xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<512x512xf32>, memref<382x446xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 256 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 256 {
 // CHECK:           affine.load %{{.*}}[%{{.*}}, %{{.*}} + 126] : memref<382x446xf32, 2>
 // CHECK-NEXT:      affine.load %{{.*}}[%{{.*}} + 62, %{{.*}}] : memref<382x446xf32, 2>
 // CHECK:           affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}} + 190] : memref<382x446xf32, 2>
 // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}} + 126, %{{.*}}] : memref<382x446xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<382x446xf32, 2>, memref<512x512xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<382x446xf32, 2>
 // CHECK-NEXT:  return
 // CHECK-NEXT:}
 
 // -----
 
 // CHECK-LABEL: func @dma_loop_straightline_interspersed() {
 func @dma_loop_straightline_interspersed() {
   %c0 = constant 0 : index
   %c255 = constant 255 : index
-  %A = alloc() : memref<256 x f32>
+  %A = memref.alloc() : memref<256 x f32>
   %v = affine.load %A[%c0] : memref<256 x f32>
   affine.for %i = 1 to 255 {
     affine.load %A[%i] : memref<256 x f32>
   }
   %l = affine.load %A[%c255] : memref<256 x f32>
   affine.store %l, %A[%c0] : memref<256 x f32>
   return
 }
 // There are three regions here - the 'load' preceding the loop, the loop
 // itself, and the operations appearing after the scf.
-// CHECK:       alloc() : memref<256xf32>
-// CHECK-NEXT:  alloc() : memref<1xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<256xf32>
+// CHECK-NEXT:  memref.alloc() : memref<1xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<1xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  affine.load %{{.*}}[0] : memref<1xf32, 2>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xf32, 2>
-// CHECK-NEXT:  alloc() : memref<254xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK-NEXT:  memref.alloc() : memref<254xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<254xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 1 to 255 {
 // CHECK-NEXT:    affine.load %{{.*}}[%{{.*}} - 1] : memref<254xf32, 2>
 // CHECK-NEXT:  }
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<254xf32, 2>
-// CHECK-NEXT:  alloc() : memref<256xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK-NEXT:  memref.alloc() : memref<256xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.load %{{.*}}[255] : memref<256xf32, 2>
 // CHECK-NEXT:  affine.store %{{.*}}, %{{.*}}[0] : memref<256xf32, 2>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32, 2>, memref<256xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<256xf32, 2>
 // CHECK-NEXT:  return
 
 // -----
 
 // CHECK-LABEL: func @dma_mixed_loop_blocks() {
 func @dma_mixed_loop_blocks() {
   %c0 = constant 0 : index
-  %A = alloc() : memref<256 x 256 x vector<8 x f32>>
+  %A = memref.alloc() : memref<256 x 256 x vector<8 x f32>>
   affine.for %i = 0 to 256 {
     %v = affine.load %A[%c0, %c0] : memref<256 x 256 x vector<8 x f32>>
     "foo"(%v) : (vector<8 x f32>) -> ()
     affine.for %j = 0 to 256 {
       %w = affine.load %A[%i, %j] : memref<256 x 256 x vector<8 x f32>>
       "bar"(%w) : (vector<8 x f32>) -> ()
     }
   }
   return
 }
-// CHECK-DAG:   [[MEM:%[0-9]+]] = alloc() : memref<256x256xvector<8xf32>>
-// CHECK-DAG:   [[BUF:%[0-9]+]] = alloc() : memref<256x256xvector<8xf32>, 2>
-// CHECK-DAG:   [[TAG:%[0-9]+]] = alloc() : memref<1xi32>
+// CHECK-DAG:   [[MEM:%[0-9]+]] = memref.alloc() : memref<256x256xvector<8xf32>>
+// CHECK-DAG:   [[BUF:%[0-9]+]] = memref.alloc() : memref<256x256xvector<8xf32>, 2>
+// CHECK-DAG:   [[TAG:%[0-9]+]] = memref.alloc() : memref<1xi32>
 // CHECK:       affine.dma_start [[MEM]][%{{.*}}, %{{.*}}], [[BUF]][%{{.*}}, %{{.*}}], [[TAG]][%{{.*}}], %{{.*}} : memref<256x256xvector<8xf32>>, memref<256x256xvector<8xf32>, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait [[TAG]][%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 256 {
 // CHECK:         affine.load [[BUF]][0, 0] : memref<256x256xvector<8xf32>, 2>
 // CHECK:         affine.for %{{.*}} = 0 to 256 {
 // CHECK-NEXT:      affine.load [[BUF]][%{{.*}}, %{{.*}}] : memref<256x256xvector<8xf32>, 2>
 
 // -----
 
 // CHECK-LABEL: func @relative_loop_bounds
 func @relative_loop_bounds(%arg0: memref<1027xf32>) {
   affine.for %i0 = 0 to 1024 {
     affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 4)>(%i0) {
       %0 = constant 0.0 : f32
       affine.store %0, %arg0[%i2] : memref<1027xf32>
     }
   }
   return
 }
-// CHECK:      [[BUF:%[0-9]+]] = alloc() : memref<1027xf32, 2>
-// CHECK-NEXT: [[MEM:%[0-9]+]] = alloc() : memref<1xi32>
+// CHECK:      [[BUF:%[0-9]+]] = memref.alloc() : memref<1027xf32, 2>
+// CHECK-NEXT: [[MEM:%[0-9]+]] = memref.alloc() : memref<1xi32>
 // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
 // CHECK-NEXT:    affine.for %[[I2:.*]] = {{#map[0-9]+}}(%{{.*}}) to {{#map[0-9]+}}(%{{.*}}) {
 // CHECK:           affine.store %{{.*}}, [[BUF]][%[[I2]]] : memref<1027xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.dma_start [[BUF]][%{{.*}}], %{{.*}}[%{{.*}}], [[MEM]][%{{.*}}], %{{.*}}  : memref<1027xf32, 2>, memref<1027xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait [[MEM]][%{{.*}}], %{{.*}} : memref<1xi32>
 
 // -----
 
 func @test_read_write_region_union() {
-  %0 = alloc() : memref<256xf32>
+  %0 = memref.alloc() : memref<256xf32>
   affine.for %i0 = 0 to 10 {
     // memref dims:  [0, 256)
     // read region:  [100, 110)
     // write region: [25, 35)
     // union region: [25, 110)
     %a0 = affine.apply affine_map<(d0) -> (d0 + 100)>(%i0)
     %a1 = affine.apply affine_map<(d0) -> (d0 + 25)>(%i0)
     %1 = affine.load %0[%a0] : memref<256xf32>
     affine.store %1, %0[%a1] : memref<256xf32>
   }
   return
 }
 
-// CHECK:       alloc() : memref<256xf32>
-// CHECK-NEXT:  alloc() : memref<85xf32, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<256xf32>
+// CHECK-NEXT:  memref.alloc() : memref<85xf32, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<85xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
 // CHECK:         affine.load %{{.*}}[%{{.*}} + 75] : memref<85xf32, 2>
 // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<85xf32, 2>
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<85xf32, 2>, memref<256xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 
 // -----
 
 // This should create a buffer of size 2 affine.for %arg2.
 
 #map_lb = affine_map<(d0) -> (d0)>
 #map_ub = affine_map<(d0) -> (d0 + 3)>
 #map_acc = affine_map<(d0) -> (d0 floordiv 8)>
 // CHECK-LABEL: func @test_analysis_util
 func @test_analysis_util(%arg0: memref<4x4x16x1xf32>, %arg1: memref<144x9xf32>, %arg2: memref<2xf32>) -> (memref<144x9xf32>, memref<2xf32>) {
   %c0 = constant 0 : index
-  %0 = alloc() : memref<64x1xf32>
-  %1 = alloc() : memref<144x4xf32>
+  %0 = memref.alloc() : memref<64x1xf32>
+  %1 = memref.alloc() : memref<144x4xf32>
   %2 =  constant 0.0 : f32
   affine.for %i8 = 0 to 9 step 3 {
     affine.for %i9 = #map_lb(%i8) to #map_ub(%i8) {
       affine.for %i17 = 0 to 64 {
         %23 = affine.apply #map_acc(%i9)
         %25 = affine.load %arg2[%23] : memref<2xf32>
         %26 = affine.apply #map_lb(%i17)
         %27 = affine.load %0[%26, %c0] : memref<64x1xf32>
         affine.store %27, %arg2[%23] : memref<2xf32>
       }
     }
   }
   return %arg1, %arg2 : memref<144x9xf32>, memref<2xf32>
 }
 // CHECK:       affine.for %{{.*}} = 0 to 9 step 3 {
-// CHECK:         [[BUF:%[0-9]+]] = alloc() : memref<2xf32, 2>
+// CHECK:         [[BUF:%[0-9]+]] = memref.alloc() : memref<2xf32, 2>
 // CHECK:         affine.dma_start %{{.*}}[%{{.*}} floordiv 8], [[BUF]]
 // CHECK:         affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK:         affine.for %{{.*}} =
 
 // -----
 
 #map3 = affine_map<(d0) -> (d0)>
 #map12 = affine_map<(d0) -> (d0 + 3)>
affine.for %i9 = #map3(%i8) to #map12(%i8) {
         %12 = affine.apply #map16(%i9, %i10)
         %13 = affine.load %arg0[%10, %11, %12, %c0] : memref<4x4x16x1xvector<8x128xf32>>
       }
     }
   }
   return %arg1, %arg2 : memref<144x9xvector<8x128xf32>>, memref<2xvector<8x128xf32>>
 }
 
-// CHECK:       alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
-// CHECK-NEXT:  alloc() : memref<1xi32>
+// CHECK:       memref.alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
+// CHECK-NEXT:  memref.alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<4x4x16x1xvector<8x128xf32>>, memref<4x4x16x1xvector<8x128xf32>, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 
 // -----
 
 // Since the fast memory size is 4 KB, DMA generation will happen right under
 // %i0.
 
 // FAST-MEM-16KB-LABEL: func @load_store_same_memref
 func @load_store_same_memref(%arg0: memref<256x1024xf32>) {
   // FAST-MEM-16KB:  affine.for %{{.*}} = 0 to 256 step 4
   affine.for %i0 = 0 to 256 step 4 {
-    // FAST-MEM-16KB: [[BUF:%[0-9]+]] = alloc() : memref<4x1024xf32, 2>
+    // FAST-MEM-16KB: [[BUF:%[0-9]+]] = memref.alloc() : memref<4x1024xf32, 2>
     // FAST-MEM-16KB:    affine.dma_start %{{.*}}
     // FAST-MEM-16KB-NEXT: affine.dma_wait
     // FAST-MEM-16KB:  affine.for %{{.*}}
     affine.for %i1 = 0 to 1024 step 4 {
       // FAST-MEM-16KB:  affine.for %{{.*}}
       affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 4)>(%i0) {
         // FAST-MEM-16KB:  affine.for %{{.*}}
         affine.for %i3 = affine_map<(d0) -> (d0)>(%i1) to affine_map<(d0) -> (d0 + 4)>(%i1) {

mlir/test/Dialect/Affine/dma.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
 // Test with loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and optional stride arguments.
 func @test1(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   %c128 = constant 128 : index
   %c256 = constant 256 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64, %c128, %c256
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and symbols (without symbol keyword).
 func @test2(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + %arg0, %i1], %1[%i0, %i1 + %arg1 + 5],
                        %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + %{{.*}} + 5], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and symbols (with symbol keyword).
 func @test3(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + symbol(%arg0), %i1],
                        %1[%i0, %i1 + symbol(%arg1) + 7],
                        %2[%i0 + %i1 + 11], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + symbol(%{{.*}}) + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, 2>
-  %2 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32>
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[(%i0 + symbol(%arg0)) floordiv 3, %i1],
                        %1[%i0, (%i1 + symbol(%arg1)) mod 9 + 7],
                        %2[%i0 + %i1 + 11], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%i0 + %i1 + 11], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3, %{{.*}}], %{{.*}}[%{{.*}}, (%{{.*}} + symbol(%{{.*}})) mod 9 + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<1xi32>
     }
   }
   return
 }

mlir/test/Dialect/Affine/invalid.mlir

 }
 
 // -----
 
 #set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @affine_if_invalid_dimop_dim(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
   affine.for %n0 = 0 to 7 {
-    %0 = alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
+    %0 = memref.alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
     %c0 = constant 0 : index
     %dim = dim %0, %c0 : memref<?x?x?x?xf32>
 
     // expected-error@+1 {{operand cannot be used as a symbol}}
     affine.if #set0(%dim)[%n0] {}
   }
   return
 }
affine.for %x = 0 to 7 {
     }
   }
   return
 }
 
 // -----
 
 func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   //  expected-error@+1 {{reduction must be specified for each output}}
   %1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) -> (f32) {
     %2 = affine.load %0[%i, %j] : memref<100x100xf32>
     affine.yield %2 : f32
   }
   return
 }
 
 // -----
 
 func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   //  expected-error@+1 {{invalid reduction value: "bad"}}
   %1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) reduce ("bad") -> (f32) {
     %2 = affine.load %0[%i, %j] : memref<100x100xf32>
     affine.yield %2 : f32
   }
   return
 }
 
 // -----
 
 func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<100x100xi32>
+  %0 = memref.alloc() : memref<100x100xi32>
   %1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) reduce ("minf") -> (f32) {
     %2 = affine.load %0[%i, %j] : memref<100x100xi32>
     //  expected-error@+1 {{types mismatch between yield op and its parent}}
     affine.yield %2 : i32
   }
   return
 }
 
 // -----
 
 func @vector_load_invalid_vector_type() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   affine.for %i0 = 0 to 16 step 8 {
     // expected-error@+1 {{requires memref and vector types of the same elemental type}}
     %1 = affine.vector_load %0[%i0] : memref<100xf32>, vector<8xf64>
   }
   return
 }
 
 // -----
 
 func @vector_store_invalid_vector_type() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %1 = constant dense<7.0> : vector<8xf64>
   affine.for %i0 = 0 to 16 step 8 {
     // expected-error@+1 {{requires memref and vector types of the same elemental type}}
     affine.vector_store %1, %0[%i0] : memref<100xf32>, vector<8xf64>
   }
   return
 }
 
 // -----
 
 func @vector_load_vector_memref() {
-  %0 = alloc() : memref<100xvector<8xf32>>
+  %0 = memref.alloc() : memref<100xvector<8xf32>>
   affine.for %i0 = 0 to 4 {
     // expected-error@+1 {{requires memref and vector types of the same elemental type}}
     %1 = affine.vector_load %0[%i0] : memref<100xvector<8xf32>>, vector<8xf32>
   }
   return
 }
 
 // -----
 
 func @vector_store_vector_memref() {
-  %0 = alloc() : memref<100xvector<8xf32>>
+  %0 = memref.alloc() : memref<100xvector<8xf32>>
   %1 = constant dense<7.0> : vector<8xf32>
   affine.for %i0 = 0 to 4 {
     // expected-error@+1 {{requires memref and vector types of the same elemental type}}
     affine.vector_store %1, %0[%i0] : memref<100xvector<8xf32>>, vector<8xf32>
   }
   return
 }
 

mlir/test/Dialect/Affine/load-store-invalid.mlir

func @store_too_few_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index, %val: f32) {
   // expected-error@+1 {{op expects as many subscripts as affine map inputs}}
   "affine.store"(%val, %arg0, %arg1)
     {map = affine_map<(i, j) -> (i, j)> } : (f32, memref<?x?xf32>, index) -> ()
 }
 
 // -----
 
 func @load_non_affine_index(%arg0 : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     %1 = muli %i0, %arg0 : index
     // expected-error@+1 {{op index must be a dimension or symbol identifier}}
     %v = affine.load %0[%1] : memref<10xf32>
   }
   return
 }
 
 // -----
 
 func @store_non_affine_index(%arg0 : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %1 = constant 11.0 : f32
   affine.for %i0 = 0 to 10 {
     %2 = muli %i0, %arg0 : index
     // expected-error@+1 {{op index must be a dimension or symbol identifier}}
     affine.store %1, %0[%2] : memref<10xf32>
   }
   return
 }
 
 // -----
 
 func @invalid_prefetch_rw(%i : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   // expected-error@+1 {{rw specifier has to be 'read' or 'write'}}
   affine.prefetch %0[%i], rw, locality<0>, data  : memref<10xf32>
   return
 }
 
 // -----
 
 func @invalid_prefetch_cache_type(%i : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   // expected-error@+1 {{cache type has to be 'data' or 'instr'}}
   affine.prefetch %0[%i], read, locality<0>, false  : memref<10xf32>
   return
 }
 
 // -----
 
 func @dma_start_non_affine_src_index(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
-  %1 = alloc() : memref<100xf32, 2>
-  %2 = alloc() : memref<1xi32, 4>
+  %0 = memref.alloc() : memref<100xf32>
+  %1 = memref.alloc() : memref<100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32, 4>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     %3 = muli %i0, %arg0 : index
     // expected-error@+1 {{op src index must be a dimension or symbol identifier}}
     affine.dma_start %0[%3], %1[%i0], %2[%c0], %c64
         : memref<100xf32>, memref<100xf32, 2>, memref<1xi32, 4>
   }
   return
 }
 
 // -----
 
 func @dma_start_non_affine_dst_index(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
-  %1 = alloc() : memref<100xf32, 2>
-  %2 = alloc() : memref<1xi32, 4>
+  %0 = memref.alloc() : memref<100xf32>
+  %1 = memref.alloc() : memref<100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32, 4>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     %3 = muli %i0, %arg0 : index
     // expected-error@+1 {{op dst index must be a dimension or symbol identifier}}
     affine.dma_start %0[%i0], %1[%3], %2[%c0], %c64
         : memref<100xf32>, memref<100xf32, 2>, memref<1xi32, 4>
   }
   return
 }
 
 // -----
 
 func @dma_start_non_affine_tag_index(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
-  %1 = alloc() : memref<100xf32, 2>
-  %2 = alloc() : memref<1xi32, 4>
+  %0 = memref.alloc() : memref<100xf32>
+  %1 = memref.alloc() : memref<100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32, 4>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     %3 = muli %i0, %arg0 : index
     // expected-error@+1 {{op tag index must be a dimension or symbol identifier}}
     affine.dma_start %0[%i0], %1[%arg0], %2[%3], %c64
         : memref<100xf32>, memref<100xf32, 2>, memref<1xi32, 4>
   }
   return
 }
 
 // -----
 
 func @dma_wait_non_affine_tag_index(%arg0 : index) {
-  %0 = alloc() : memref<100xf32>
-  %1 = alloc() : memref<100xf32, 2>
-  %2 = alloc() : memref<1xi32, 4>
+  %0 = memref.alloc() : memref<100xf32>
+  %1 = memref.alloc() : memref<100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32, 4>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     %3 = muli %i0, %arg0 : index
     // expected-error@+1 {{op index must be a dimension or symbol identifier}}
     affine.dma_wait %2[%3], %c64 : memref<1xi32, 4>
   }
   return
 }

mlir/test/Dialect/Affine/load-store.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
 // Test with just loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and constants.
 func @test1(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and function args without 'symbol' keyword (should
 // be parsed as dim identifiers).
 func @test2(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
       affine.store %1, %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and function args with 'symbol' keyword (should
 // be parsed as symbol identifiers).
 func @test3(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
       affine.store %1, %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
       affine.store %1, %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with swizzled loop IVs.
 func @test5(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<10x10x10xf32>
+  %0 = memref.alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2, %i0, %i1] : memref<10x10x10xf32>
         affine.store %1, %0[%i2, %i0, %i1] : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
 // Test with swizzled loop IVs, duplicate args, and function args used as dims.
 // Dim identifiers are assigned in parse order:
 // d0 = %i2, d1 = %arg0, d2 = %i0, d3 = %i1, d4 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<10x10x10xf32>
+  %0 = memref.alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
         affine.store %1, %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
 // Test with swizzled loop IVs, duplicate args, and function args used as syms.
 // Dim and symbol identifiers are assigned in parse order:
 // d0 = %i2, d1 = %i0, d2 = %i1
 // s0 = %arg0, s1 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<10x10x10xf32>
+  %0 = memref.alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2 + symbol(%arg0),
                             %i0 + %i1,
                             %i1 + symbol(%arg0) + symbol(%arg1)]
                               : memref<10x10x10xf32>
         affine.store %1, %0[%i2 + symbol(%arg0),

 }
 
 // -----
 
 // CHECK: [[MAP0:#map[0-9]*]] = affine_map<(d0) -> (d0 + 1)>
 
 // Test with operands without special SSA name.
 func @test7() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     %1 = affine.apply affine_map<(d1) -> (d1 + 1)>(%i0)
     %2 = affine.load %0[%1] : memref<10xf32>
     affine.store %2, %0[%1] : memref<10xf32>
 // CHECK: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   }
   return
func @zero_dim(%arg0 : memref<i32>, %arg1 : memref<i32>) {
   // CHECK: affine.store %{{.*}}, %{{.*}}[] : memref<i32>
   return
 }
 
 // -----
 
 // Test with loop IVs and constants.
 func @test_prefetch(%arg0 : index, %arg1 : index) {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.prefetch %0[%i0 + 3, %i1 + 11], write, locality<0>, data : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}} + 3, %{{.*}} + 11], write, locality<0>, data : memref<100x100xf32>
       affine.prefetch %0[%i0, %i1 + 1], read, locality<3>, instr : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}}, %{{.*}} + 1], read, locality<3>, instr : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with just loop IVs.
 func @vector_load_vector_store_iv() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 16 {
     affine.for %i1 = 0 to 16 step 8 {
       %1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
       affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
-// CHECK:      %[[buf:.*]] = alloc
+// CHECK:      %[[buf:.*]] = memref.alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<8xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<8xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test with loop IVs and constants.
 func @vector_load_vector_store_iv_constant() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 16 step 4 {
       %1 = affine.vector_load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
       affine.vector_store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
-// CHECK:      %[[buf:.*]] = alloc
+// CHECK:      %[[buf:.*]] = memref.alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>, vector<4xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]] + 3, %[[i1]] + 7] : memref<100x100xf32>, vector<4xf32>
     }
   }
   return
 }
 
 // -----
 
 func @vector_load_vector_store_2d() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 16 step 2{
     affine.for %i1 = 0 to 16 step 8 {
       %1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
       affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
-// CHECK:      %[[buf:.*]] = alloc
+// CHECK:      %[[buf:.*]] = memref.alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
     }
   }
   return
 }

mlir/test/Dialect/Affine/loop-tiling-validity.mlir

 // RUN: mlir-opt %s  -split-input-file -affine-loop-tile="tile-size=32" -verify-diagnostics | FileCheck %s
 
 // -----
 
 // There is no dependence violated in this case. No error should be raised.
 
 // CHECK-DAG: [[$LB:#map[0-9]+]] = affine_map<(d0) -> (d0)>
 // CHECK-DAG: [[$UB:#map[0-9]+]] = affine_map<(d0) -> (d0 + 32)>
 
 // CHECK-LABEL: func @legal_loop()
 func @legal_loop() {
-  %0 = alloc() : memref<64xf32>
+  %0 = memref.alloc() : memref<64xf32>
 
   affine.for %i = 0 to 64 {
     %1 = affine.load %0[%i] : memref<64xf32>
     %2 = addf %1, %1 : f32
     affine.store %2, %0[%i] : memref<64xf32>
   }
 
   return
 }
 
 // CHECK:   affine.for %{{.*}} = 0 to 64 step 32 {
 // CHECK-NEXT:     affine.for %{{.*}} = [[$LB]](%{{.*}}) to [[$UB]](%{{.*}}) {
 
 // -----
 
 // There are dependences along the diagonal of the 2d iteration space,
 // specifically, they are of direction (+, -).
 // The default tiling method (hyper-rect) will violate tiling legality.
 // We expect a remark that points that issue out to be emitted.
 
 // CHECK-LABEL: func @illegal_loop_with_diag_dependence
 func @illegal_loop_with_diag_dependence() {
-  %A = alloc() : memref<64x64xf32>
+  %A = memref.alloc() : memref<64x64xf32>
 
   affine.for %i = 0 to 64 {
     // expected-remark@above {{tiled code is illegal due to dependences}}
     affine.for %j = 0 to 64 {
       %0 = affine.load %A[%j, %i] : memref<64x64xf32>
       %1 = affine.load %A[%i, %j - 1] : memref<64x64xf32>
       %2 = addf %0, %1 : f32
       affine.store %2, %A[%i, %j] : memref<64x64xf32>
     }
   }
 
   return
 }

mlir/test/Dialect/Affine/memref-stride-calculation.mlir

 // RUN: mlir-opt %s -test-memref-stride-calculation -o /dev/null | FileCheck %s
 
 func @f(%0: index) {
 // CHECK-LABEL: Testing: f
-  %1 = alloc() : memref<3x4x5xf32>
+  %1 = memref.alloc() : memref<3x4x5xf32>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %2 = alloc(%0) : memref<3x4x?xf32>
+  %2 = memref.alloc(%0) : memref<3x4x?xf32>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %3 = alloc(%0) : memref<3x?x5xf32>
+  %3 = memref.alloc(%0) : memref<3x?x5xf32>
 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
-  %4 = alloc(%0) : memref<?x4x5xf32>
+  %4 = memref.alloc(%0) : memref<?x4x5xf32>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %5 = alloc(%0, %0) : memref<?x4x?xf32>
+  %5 = memref.alloc(%0, %0) : memref<?x4x?xf32>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %6 = alloc(%0, %0, %0) : memref<?x?x?xf32>
+  %6 = memref.alloc(%0, %0, %0) : memref<?x?x?xf32>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
 
-  %11 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %11 = memref.alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %b11 = alloc() : memref<3x4x5xf32, offset: 0, strides: [20, 5, 1]>
+  %b11 = memref.alloc() : memref<3x4x5xf32, offset: 0, strides: [20, 5, 1]>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %12 = alloc(%0) : memref<3x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %12 = memref.alloc(%0) : memref<3x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %13 = alloc(%0) : memref<3x?x5xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %13 = memref.alloc(%0) : memref<3x?x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
-  %14 = alloc(%0) : memref<?x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %14 = memref.alloc(%0) : memref<?x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %15 = alloc(%0, %0) : memref<?x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %15 = memref.alloc(%0, %0) : memref<?x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %16 = alloc(%0, %0, %0) : memref<?x?x?xf32, affine_map<(i, j, k)->(i, j, k)>>
+  %16 = memref.alloc(%0, %0, %0) : memref<?x?x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
 
-  %21 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + 16 * j + M * k + 1)>>
+  %21 = memref.alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + 16 * j + M * k + 1)>>
 // CHECK: MemRefType offset: 1 strides: 32, 16, ?
-  %22 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + M * j + 16 * k + 3)>>
+  %22 = memref.alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + M * j + 16 * k + 3)>>
 // CHECK: MemRefType offset: 3 strides: 32, ?, 16
-  %b22 = alloc(%0)[%0, %0] : memref<3x4x?xf32, offset: 0, strides: [?, ?, 1]>
+  %b22 = memref.alloc(%0)[%0, %0] : memref<3x4x?xf32, offset: 0, strides: [?, ?, 1]>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %23 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + 7)>>
+  %23 = memref.alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + 7)>>
 // CHECK: MemRefType offset: 7 strides: ?, 32, 16
-  %b23 = alloc(%0)[%0] : memref<3x?x5xf32, offset: 0, strides: [?, 5, 1]>
+  %b23 = memref.alloc(%0)[%0] : memref<3x?x5xf32, offset: 0, strides: [?, 5, 1]>
 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
-  %24 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + M)>>
+  %24 = memref.alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + M)>>
 // CHECK: MemRefType offset: ? strides: ?, 32, 16
-  %b24 = alloc(%0)[%0, %0] : memref<3x?x5xf32, offset: ?, strides: [?, 32, 16]>
+  %b24 = memref.alloc(%0)[%0, %0] : memref<3x?x5xf32, offset: ?, strides: [?, 32, 16]>
 // CHECK: MemRefType offset: ? strides: ?, 32, 16
-  %25 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
+  %25 = memref.alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
 // CHECK: MemRefType offset: 1 strides: ?, ?, 1
-  %b25 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, offset: 1, strides: [?, ?, 1]>
+  %b25 = memref.alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, offset: 1, strides: [?, ?, 1]>
 // CHECK: MemRefType offset: 1 strides: ?, ?, 1
-  %26 = alloc(%0)[] : memref<?xf32, affine_map<(i)[M]->(i)>>
+  %26 = memref.alloc(%0)[] : memref<?xf32, affine_map<(i)[M]->(i)>>
 // CHECK: MemRefType offset: 0 strides: 1
-  %27 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(M)>>
+  %27 = memref.alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(M)>>
 // CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (s0)>> cannot be converted to strided form
-  %28 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(123)>>
+  %28 = memref.alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(123)>>
 // CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (123)>> cannot be converted to strided form
-  %29 = alloc()[%0] : memref<f32, affine_map<()[M]->(M)>>
+  %29 = memref.alloc()[%0] : memref<f32, affine_map<()[M]->(M)>>
 // CHECK: MemRefType offset: ? strides:
-  %30 = alloc()[%0] : memref<f32, affine_map<()[M]->(123)>>
+  %30 = memref.alloc()[%0] : memref<f32, affine_map<()[M]->(123)>>
 // CHECK: MemRefType offset: 123 strides:
 
-  %100 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(i + j, j, k)>, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
+  %100 = memref.alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(i + j, j, k)>, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
 // CHECK: MemRefType memref<?x?x16xf32, affine_map<(d0, d1, d2)[s0, s1] -> (d0 + d1, d1, d2)>, affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2 + 1)>> cannot be converted to strided form
-  %101 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i floordiv 4 + j + k)>>
+  %101 = memref.alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i floordiv 4 + j + k)>>
 // CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 floordiv 4 + d1 + d2)>> cannot be converted to strided form
-  %102 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i ceildiv 4 + j + k)>>
+  %102 = memref.alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i ceildiv 4 + j + k)>>
 // CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 ceildiv 4 + d1 + d2)>> cannot be converted to strided form
-  %103 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i mod 4 + j + k)>>
+  %103 = memref.alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i mod 4 + j + k)>>
 // CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 mod 4 + d1 + d2)>> cannot be converted to strided form
 
-  %200 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>>
+  %200 = memref.alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>>
   // CHECK: MemRefType offset: 0 strides: 20, ?, ?
-  %201 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>>
+  %201 = memref.alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>>
   // CHECK: MemRefType offset: ? strides: 20, ?, ?
-  %202 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * (i + 1) + j + k - M)>>
+  %202 = memref.alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * (i + 1) + j + k - M)>>
   // CHECK: MemRefType offset: 0 strides: ?, 1, 1
-  %203 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M + M * (i + N * (j + K * k)))>>
+  %203 = memref.alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M + M * (i + N * (j + K * k)))>>
   // CHECK: MemRefType offset: ? strides: ?, ?, ?
 
   return
 }

mlir/test/Dialect/Affine/ops.mlir

func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) {
   return
 }
 
 // -----
 
 func @valid_symbols(%arg0: index, %arg1: index, %arg2: index) {
   %c1 = constant 1 : index
   %c0 = constant 0 : index
-  %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   affine.for %arg3 = 0 to %arg2 step 768 {
     %13 = dim %0, %c1 : memref<?x?xf32>
     affine.for %arg4 = 0 to %13 step 264 {
       %18 = dim %0, %c0 : memref<?x?xf32>
       %20 = std.subview %0[%c0, %c0][%18,%arg4][%c1,%c1] : memref<?x?xf32>
                           to memref<?x?xf32, offset : ?, strides : [?, ?]>
       %24 = dim %20, %c0 : memref<?x?xf32, offset : ?, strides : [?, ?]>
       affine.for %arg5 = 0 to %24 step 768 {

mlir/test/Dialect/Affine/parallelize.mlir

 // RUN: mlir-opt %s -allow-unregistered-dialect -affine-parallelize| FileCheck %s
 // RUN: mlir-opt %s -allow-unregistered-dialect -affine-parallelize='max-nested=1' | FileCheck --check-prefix=MAX-NESTED %s
 
 // CHECK-LABEL:    func @reduce_window_max() {
 func @reduce_window_max() {
   %cst = constant 0.000000e+00 : f32
-  %0 = alloc() : memref<1x8x8x64xf32>
-  %1 = alloc() : memref<1x18x18x64xf32>
+  %0 = memref.alloc() : memref<1x8x8x64xf32>
+  %1 = memref.alloc() : memref<1x18x18x64xf32>
   affine.for %arg0 = 0 to 1 {
     affine.for %arg1 = 0 to 8 {
       affine.for %arg2 = 0 to 8 {
         affine.for %arg3 = 0 to 64 {
           affine.store %cst, %0[%arg0, %arg1, %arg2, %arg3] : memref<1x8x8x64xf32>
         }
       }
     }
affine.for %arg1 = 0 to 8 {
         }
       }
     }
   }
   return
 }
 
 // CHECK:        %[[cst:.*]] = constant 0.000000e+00 : f32
-// CHECK:        %[[v0:.*]] = alloc() : memref<1x8x8x64xf32>
-// CHECK:        %[[v1:.*]] = alloc() : memref<1x18x18x64xf32>
+// CHECK:        %[[v0:.*]] = memref.alloc() : memref<1x8x8x64xf32>
+// CHECK:        %[[v1:.*]] = memref.alloc() : memref<1x18x18x64xf32>
 // CHECK:        affine.parallel (%[[arg0:.*]]) = (0) to (1) {
 // CHECK:          affine.parallel (%[[arg1:.*]]) = (0) to (8) {
 // CHECK:            affine.parallel (%[[arg2:.*]]) = (0) to (8) {
 // CHECK:              affine.parallel (%[[arg3:.*]]) = (0) to (64) {
 // CHECK:                affine.store %[[cst]], %[[v0]][%[[arg0]], %[[arg1]], %[[arg2]], %[[arg3]]] : memref<1x8x8x64xf32>
 // CHECK:              }
 // CHECK:            }
 // CHECK:          }

 // CHECK:                }
 // CHECK:              }
 // CHECK:            }
 // CHECK:          }
 // CHECK:        }
 // CHECK:      }
 
 func @loop_nest_3d_outer_two_parallel(%N : index) {
-  %0 = alloc() : memref<1024 x 1024 x vector<64xf32>>
-  %1 = alloc() : memref<1024 x 1024 x vector<64xf32>>
-  %2 = alloc() : memref<1024 x 1024 x vector<64xf32>>
+  %0 = memref.alloc() : memref<1024 x 1024 x vector<64xf32>>
+  %1 = memref.alloc() : memref<1024 x 1024 x vector<64xf32>>
+  %2 = memref.alloc() : memref<1024 x 1024 x vector<64xf32>>
   affine.for %i = 0 to %N {
     affine.for %j = 0 to %N {
       %7 = affine.load %2[%i, %j] : memref<1024x1024xvector<64xf32>>
       affine.for %k = 0 to %N {
         %5 = affine.load %0[%i, %k] : memref<1024x1024xvector<64xf32>>
         %6 = affine.load %1[%k, %j] : memref<1024x1024xvector<64xf32>>
         %8 = mulf %5, %6 : vector<64xf32>
         %9 = addf %7, %8 : vector<64xf32>

 // CHECK:  affine.for %[[arg1:.*]] = 0 to 10 {
     "unknown"() : () -> ()
   }
   return
 }
 
 // CHECK-LABEL: non_affine_load
 func @non_affine_load() {
-  %0 = alloc() : memref<100 x f32>
+  %0 = memref.alloc() : memref<100 x f32>
   affine.for %i = 0 to 100 {
 // CHECK:  affine.for %{{.*}} = 0 to 100 {
     load %0[%i] : memref<100 x f32>
   }
   return
 }
 
 // CHECK-LABEL: for_with_minmax

mlir/test/Dialect/Affine/slicing-utils.mlir

 ///     |_______________|
 ///             |
 ///             9
 // FWD-LABEL: slicing_test
 // BWD-LABEL: slicing_test
 // FWDBWD-LABEL: slicing_test
 func @slicing_test() {
   // Fake 0 to align on 1 and match ASCII art.
-  %0 = alloc() : memref<1xi32>
+  %0 = memref.alloc() : memref<1xi32>
 
   // FWD: matched: %[[v1:.*]] {{.*}} forward static slice:
   // FWD-NEXT: %[[v5:.*]] {{.*}} -> i5
   // FWD-DAG: %[[v8:.*]] {{.*}} -> i8
   // FWD-DAG: %[[v7:.*]] {{.*}} -> i7
   // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
   //
   // BWD: matched: %[[v1:.*]] {{.*}} backward static slice:

mlir/test/Dialect/Affine/unroll.mlir

func @loop_nest_outer_unroll() {
   return  // SHORT:  return
 }         // SHORT }
 
 // We are doing a minimal FileCheck here. We just need this test case to
 // successfully run. Both %x and %y will get unrolled here as the min trip
 // count threshold set to 2.
 // SHORT-LABEL: func @loop_nest_seq_long() -> i32 {
 func @loop_nest_seq_long() -> i32 {
-  %A = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %B = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-  %C = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %A = memref.alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %B = memref.alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %C = memref.alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
 
   %zero = constant 0 : i32
   %one = constant 1 : i32
   %two = constant 2 : i32
 
   %zero_idx = constant 0 : index
 
   // CHECK: affine.for %arg0 = 0 to 512
   affine.for %n0 = 0 to 512 {
     // CHECK: affine.for %arg1 = 0 to 8
     affine.for %n1 = 0 to 8 {
-      store %one,  %A[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-      store %two,  %B[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
-      store %zero, %C[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+      memref.store %one,  %A[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+      memref.store %two,  %B[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+      memref.store %zero, %C[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
     }
   }
 
   affine.for %x = 0 to 2 {
     affine.for %y = 0 to 2 {
       // CHECK: affine.for
       affine.for %arg2 = 0 to 8 {
         // CHECK-NOT: affine.for
         // CHECK: %{{[0-9]+}} = affine.apply
         %b2 = "affine.apply" (%y, %arg2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
         %z = load %B[%x, %b2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
         "op1"(%z) : (i32) -> ()
       }
       affine.for %j1 = 0 to 8 {
         affine.for %j2 = 0 to 8 {
           %a2 = "affine.apply" (%y, %j2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
           %v203 = load %A[%j1, %a2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
           "op2"(%v203) : (i32) -> ()
         }
         affine.for %k2 = 0 to 8 {
           %s0 = "op3"() : () -> i32
           %c2 = "affine.apply" (%x, %k2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
           %s1 =  load %C[%j1, %c2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
           %s2 = "addi32"(%s0, %s1) : (i32, i32) -> i32
-          store %s2, %C[%j1, %c2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+          memref.store %s2, %C[%j1, %c2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
         }
       }
       "op4"() : () -> ()
     }
   }
   %ret = load %C[%zero_idx, %zero_idx] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   return %ret : i32
 }

mlir/test/Dialect/Async/async-parallel-for.mlir

 // RUN: mlir-opt %s -async-parallel-for | FileCheck %s
 
 // CHECK-LABEL: @loop_1d
 func @loop_1d(%arg0: index, %arg1: index, %arg2: index, %arg3: memref<?xf32>) {
   // CHECK: %[[GROUP:.*]] = async.create_group
   // CHECK: scf.for
   // CHECK:   %[[TOKEN:.*]] = async.execute {
   // CHECK:     scf.for
-  // CHECK:       store
+  // CHECK:       memref.store
   // CHECK:     async.yield
   // CHECK:   }
   // CHECK:   async.add_to_group %[[TOKEN]], %[[GROUP]]
   // CHECK: async.await_all %[[GROUP]]
   scf.parallel (%i) = (%arg0) to (%arg1) step (%arg2) {
     %one = constant 1.0 : f32
-    store %one, %arg3[%i] : memref<?xf32>
+    memref.store %one, %arg3[%i] : memref<?xf32>
   }
 
   return
 }
 
 // CHECK-LABEL: @loop_2d
 func @loop_2d(%arg0: index, %arg1: index, %arg2: index, // lb, ub, step
               %arg3: index, %arg4: index, %arg5: index, // lb, ub, step
               %arg6: memref<?x?xf32>) {
   // CHECK: %[[GROUP:.*]] = async.create_group
   // CHECK: scf.for
   // CHECK:   scf.for
   // CHECK:     %[[TOKEN:.*]] = async.execute {
   // CHECK:       scf.for
   // CHECK:         scf.for
-  // CHECK:           store
+  // CHECK:           memref.store
   // CHECK:       async.yield
   // CHECK:     }
   // CHECK:     async.add_to_group %[[TOKEN]], %[[GROUP]]
   // CHECK: async.await_all %[[GROUP]]
   scf.parallel (%i0, %i1) = (%arg0, %arg3) to (%arg1, %arg4)
                             step (%arg2, %arg5) {
     %one = constant 1.0 : f32
-    store %one, %arg6[%i0, %i1] : memref<?x?xf32>
+    memref.store %one, %arg6[%i0, %i1] : memref<?x?xf32>
   }
 
   return
 }

mlir/test/Dialect/Async/async-to-async-runtime.mlir

 // RUN: mlir-opt %s -split-input-file -async-to-async-runtime -print-ir-after-all | FileCheck %s --dump-input=always
 
 // CHECK-LABEL: @execute_no_async_args
 func @execute_no_async_args(%arg0: f32, %arg1: memref<1xf32>) {
   %token = async.execute {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   async.await %token : !async.token
   return
 }
 
 // Function outlined from the async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn
 // CHECK-SAME: -> !async.token
 
 // Create token for return op, and mark a function as a coroutine.
 // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
 // CHECK: %[[ID:.*]] = async.coro.id
 // CHECK: %[[HDL:.*]] = async.coro.begin
 
 // Pass a suspended coroutine to the async runtime.
 // CHECK: %[[SAVED:.*]] = async.coro.save %[[HDL]]
 // CHECK: async.runtime.resume %[[HDL]]
 // CHECK: async.coro.suspend %[[SAVED]]
 // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
 
 // Resume coroutine after suspension.
 // CHECK: ^[[RESUME]]:
-// CHECK:   store
+// CHECK:   memref.store
 // CHECK:   async.runtime.set_available %[[TOKEN]]
 
 // Delete coroutine.
 // CHECK: ^[[CLEANUP]]:
 // CHECK:   async.coro.free %[[ID]], %[[HDL]]
 
 // Suspend coroutine, and also a return statement for ramp function.
 // CHECK: ^[[SUSPEND]]:
 // CHECK:   async.coro.end %[[HDL]]
 // CHECK:   return %[[TOKEN]]
 
 // -----
 
 // CHECK-LABEL: @nested_async_execute
 func @nested_async_execute(%arg0: f32, %arg1: f32, %arg2: memref<1xf32>) {
   // CHECK: %[[TOKEN:.*]] = call @async_execute_fn_0(%arg0, %arg2, %arg1)
   %token0 = async.execute {
     %c0 = constant 0 : index
 
     %token1 = async.execute {
       %c1 = constant 1: index
-      store %arg0, %arg2[%c0] : memref<1xf32>
+      memref.store %arg0, %arg2[%c0] : memref<1xf32>
       async.yield
     }
     async.await %token1 : !async.token
 
-    store %arg1, %arg2[%c0] : memref<1xf32>
+    memref.store %arg1, %arg2[%c0] : memref<1xf32>
     async.yield
   }
   // CHECK: async.runtime.await %[[TOKEN]]
   // CHECK-NEXT: return
   async.await %token0 : !async.token
   return
 }
 
 // Function outlined from the inner async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn
 // CHECK-SAME: -> !async.token
 
 // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
 // CHECK: %[[ID:.*]] = async.coro.id
 // CHECK: %[[HDL:.*]] = async.coro.begin
 
 // CHECK: async.runtime.resume %[[HDL]]
 // CHECK: async.coro.suspend
 // CHECK-SAME: ^[[SUSPEND:.*]], ^[[RESUME:.*]], ^[[CLEANUP:.*]]
 
 // CHECK: ^[[RESUME]]:
-// CHECK:   store
+// CHECK:   memref.store
 // CHECK:   async.runtime.set_available %[[TOKEN]]
 
 // Function outlined from the outer async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn_0
 // CHECK-SAME: -> !async.token
 
 // CHECK: %[[TOKEN:.*]] = async.runtime.create : !async.token
 // CHECK: %[[ID:.*]] = async.coro.id

 // CHECK:   %[[INNER_TOKEN:.*]] = call @async_execute_fn
 // CHECK:   %[[SAVED:.*]] = async.coro.save %[[HDL]]
 // CHECK:   async.runtime.await_and_resume %[[INNER_TOKEN]], %[[HDL]]
 // CHECK:   async.coro.suspend %[[SAVED]]
 // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
 
 // Set token available after second resumption.
 // CHECK: ^[[RESUME_1]]:
-// CHECK:   store
+// CHECK:   memref.store
 // CHECK:   async.runtime.set_available %[[TOKEN]]
 
 // CHECK: ^[[CLEANUP]]:
 // CHECK: ^[[SUSPEND]]:
 
 // -----
 
 // CHECK-LABEL: @async_execute_token_dependency
 func @async_execute_token_dependency(%arg0: f32, %arg1: memref<1xf32>) {
   // CHECK: %[[TOKEN:.*]] = call @async_execute_fn
   %token = async.execute {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   // CHECK: call @async_execute_fn_0(%[[TOKEN]], %arg0, %arg1)
   %token_0 = async.execute [%token] {
     %c0 = constant 0 : index
-    store %arg0, %arg1[%c0] : memref<1xf32>
+    memref.store %arg0, %arg1[%c0] : memref<1xf32>
     async.yield
   }
   return
 }
 
 // Function outlined from the first async.execute operation.
 // CHECK-LABEL: func private @async_execute_fn
 // CHECK-SAME: -> !async.token

 // CHECK: ^[[RESUME_0]]:
 // CHECK:   %[[SAVED:.*]] = async.coro.save %[[HDL]]
 // CHECK:   async.runtime.await_and_resume %[[ARG0]], %[[HDL]]
 // CHECK:   async.coro.suspend %[[SAVED]]
 // CHECK-SAME: ^[[SUSPEND]], ^[[RESUME_1:.*]], ^[[CLEANUP]]
 
 // Emplace result token after second resumption.
 // CHECK: ^[[RESUME_1]]:
-// CHECK:   store
+// CHECK:   memref.store
 // CHECK:   async.runtime.set_available %[[TOKEN]]
 
 // CHECK: ^[[CLEANUP]]:
 // CHECK: ^[[SUSPEND]]:
 
 // -----
 
 // CHECK-LABEL: @async_group_await_all

mlir/test/Dialect/GPU/multiple-all-reduce.mlir

 // RUN: mlir-opt --gpu-kernel-outlining --convert-gpu-to-nvvm %s | FileCheck %s
 
 func @main() {
-  %data = alloc() : memref<2x6xf32>
-  %sum = alloc() : memref<2xf32>
-  %mul = alloc() : memref<2xf32>
+  %data = memref.alloc() : memref<2x6xf32>
+  %sum = memref.alloc() : memref<2xf32>
+  %mul = memref.alloc() : memref<2xf32>
   %c1 = constant 1 : index
 
   // ADD + MUL
   gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1, %grid_z = %c1)
              threads(%tx, %ty, %tz) in (%block_x = %c1, %block_y = %c1, %block_z = %c1) {
     %val = load %data[%bx, %tx] : memref<2x6xf32>
     %reduced0 = "gpu.all_reduce"(%val) ({}) { op = "add" } : (f32) -> (f32)
-    store %reduced0, %sum[%bx] : memref<2xf32>
+    memref.store %reduced0, %sum[%bx] : memref<2xf32>
     %reduced1 = "gpu.all_reduce"(%val) ({}) { op = "mul" } : (f32) -> (f32)
-    store %reduced1, %mul[%bx] : memref<2xf32>
+    memref.store %reduced1, %mul[%bx] : memref<2xf32>
     gpu.terminator
   }
 
 // CHECK:      gpu.module @main_kernel {
 // CHECK-NEXT:   llvm.mlir.global internal @{{.*}}() {addr_space = 3 : i32} : !llvm.array<32 x f32>
 // CHECK-NEXT:   llvm.mlir.global internal @{{.*}}() {addr_space = 3 : i32} : !llvm.array<32 x f32>
 
   return
 }

mlir/test/Dialect/Linalg/affine.mlir

 // RUN: mlir-opt %s -convert-linalg-to-affine-loops | FileCheck %s
 
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // RUN: mlir-opt %s -convert-linalg-to-affine-loops -convert-linalg-to-llvm -o=/dev/null 2>&1
 
 // CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
 
 // CHECK-DAG: #[[$stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
 
 // CHECK-DAG: #[[$clampMinMap:.*]] = affine_map<(d0) -> (d0, 0)>
 
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %A = view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
-  %B = view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
-  %C = view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
+  %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
+  %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
   linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
                outs(%C: memref<?x?xf32>)
   return
 }
 
 // CHECK-LABEL: func @matmul(%{{.*}}: memref<?xi8>,
 // CHECK-SAME: [[M:arg[0-9]+]]: index
 // CHECK-SAME: [[N:arg[0-9]+]]: index
 // CHECK-SAME: [[K:arg[0-9]+]]: index
-//       CHECK: %[[A:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECK: %[[B:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECK: %[[C:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK: %[[A:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK: %[[B:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK: %[[C:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECK: affine.for %{{.*}}  = 0 to %{{.*}} {
 //       CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
 //       CHECK:     affine.for %{{.*}} = 0 to %{{.*}} {
 //   CHECK-DAG:       %[[a:.*]] = affine.load %[[A]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECK-DAG:       %[[b:.*]] = affine.load %[[B]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECK-DAG:       %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECK-DAG:       %[[c:.*]] = affine.load %[[C]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECK-DAG:       %[[res:.*]] = addf %[[c]], %[[inc]] : f32

mlir/test/Dialect/Linalg/bufferize.mlir

 // RUN: mlir-opt -linalg-bufferize  -canonicalize -cse -split-input-file %s | FileCheck %s
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // In-depth checking of a basic case, this is testing
 // - tensor_to_memref / tensor_load materializations are properly inserted
 // - payload is correctly carried over
 // - affine maps are correctly carried over
 // Later tests will not check all these details.
 
 // CHECK: #map = affine_map<(d0) -> (d0)>
 // CHECK-LABEL:   func @basic(
 // CHECK-SAME:                %[[TENSOR:.*]]: tensor<4xf32>) -> tensor<4xf32> {
 // CHECK:           %[[MEMREF:.*]] = tensor_to_memref %[[TENSOR]] : memref<4xf32>
-// CHECK:           %[[RESULT_MEMREF:.*]] = alloc() : memref<4xf32>
+// CHECK:           %[[RESULT_MEMREF:.*]] = memref.alloc() : memref<4xf32>
 // CHECK:           linalg.generic {indexing_maps = [#map, #map], iterator_types = ["parallel"]}
 // CHECK-SAME:      ins(%[[MEMREF]] : memref<4xf32>)
 // CHECK-SAME:      outs(%[[RESULT_MEMREF]] : memref<4xf32>) {
 // CHECK:           ^bb0(%[[RESULT1:.*]]: f32, %[[UNUSED:.*]]: f32):
 // CHECK:             %[[DIM1:.*]] = math.exp %[[RESULT1]] : f32
 // CHECK:             linalg.yield %[[DIM1]] : f32
 // CHECK:           }
 // CHECK:           %[[RESULT:.*]] = tensor_load %[[RESULT_MEMREF]] : memref<4xf32>

 
 #map0 = affine_map<(d0) -> (d0)>
 
 // Same as above but with linalg.init_tensor op.
 
 // CHECK: #map = affine_map<(d0) -> (d0)>
 // CHECK-LABEL: func @init_tensor(
 // CHECK-SAME:      %[[IN:.*]]: tensor<?xf32>, %[[SIZE:.*]]: index)
-// CHECK:         %[[OUT_BUF:.*]] = alloc(%[[SIZE]]) : memref<?xf32>
+// CHECK:         %[[OUT_BUF:.*]] = memref.alloc(%[[SIZE]]) : memref<?xf32>
 // CHECK:         %[[MEMREF:.*]] = tensor_to_memref %[[IN]] : memref<?xf32>
 // CHECK:         linalg.generic
 // CHECK-SAME:    ins(%[[MEMREF]] : memref<?xf32>)
 // CHECK-SAME:    outs(%[[OUT_BUF]] : memref<?xf32>) {
 func @init_tensor(%in : tensor<?xf32>, %size: index) -> tensor<?xf32> {
   %init = linalg.init_tensor [%size] : tensor<?xf32>
   %0 = linalg.generic {
     indexing_maps = [#map0, #map0],
     iterator_types = ["parallel"]
   } ins(%in : tensor<?xf32>)
     outs(%init : tensor<?xf32>) {
     ^bb0(%gen_arg1: f32, %out: f32):
       %tmp1 = math.exp %gen_arg1 : f32
       linalg.yield %tmp1 : f32
   } -> tensor<?xf32>
   return %0 : tensor<?xf32>
 }
 
 
 // -----
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL:   func @multiple_results
-// CHECK:           %[[RESULT0:.*]] = alloc() : memref<4xf32>
-// CHECK:           %[[RESULT1:.*]] = alloc() : memref<4xf32>
+// CHECK:           %[[RESULT0:.*]] = memref.alloc() : memref<4xf32>
+// CHECK:           %[[RESULT1:.*]] = memref.alloc() : memref<4xf32>
 // CHECK:           linalg.generic
 // CHECK-SAME:      ins(%{{.*}} : memref<4xf32>)
 // CHECK-SAME:      outs(%[[RESULT0]], %[[RESULT1]] : memref<4xf32>, memref<4xf32>)
 // CHECK-NEXT: ^bb0(%{{.*}}: f32, %{{.*}}: f32, %{{.*}}: f32):
 func @multiple_results(%arg0: tensor<4xf32>) -> (tensor<4xf32>, tensor<4xf32>) {
     %0, %1 = linalg.generic {
       indexing_maps = [#map0, #map0, #map0],
       iterator_types = ["parallel"]
     } ins(%arg0 : tensor<4xf32>)
       outs (%arg0, %arg0 : tensor<4xf32>, tensor<4xf32>) {
       ^bb0(%gen_arg1: f32, %out1: f32, %out2: f32):
         %tmp1 = math.exp %gen_arg1 : f32
         linalg.yield %tmp1, %tmp1 : f32, f32
     } -> tensor<4xf32>, tensor<4xf32>
     return %0, %1 : tensor<4xf32>, tensor<4xf32>
 }
 
 // -----
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL:   func @multiple_results_indexed
-// CHECK:           %[[RESULT0:.*]] = alloc() : memref<4xi32>
-// CHECK:           %[[RESULT1:.*]] = alloc() : memref<4xi32>
+// CHECK:           %[[RESULT0:.*]] = memref.alloc() : memref<4xi32>
+// CHECK:           %[[RESULT1:.*]] = memref.alloc() : memref<4xi32>
 // CHECK:           linalg.indexed_generic
 // CHECK-SAME:      ins(%{{.*}} : memref<4xi32>)
 // CHECK-SAME:      outs(%[[RESULT0]], %[[RESULT1]] : memref<4xi32>, memref<4xi32>)
 // CHECK-NEXT: ^bb0(%{{.*}}: index, %{{.*}}: i32, %{{.*}}: i32, %{{.*}}: i32):
 func @multiple_results_indexed(%arg0: tensor<4xi32>)
         -> (tensor<4xi32>, tensor<4xi32>) {
     %0, %1 = linalg.indexed_generic {
       indexing_maps = [#map0, #map0, #map0],

 
 // CHECK-LABEL:   func @dynamic_results(
 // CHECK-SAME:                          %[[ARG:.*]]: tensor<?x?xf32>
 // CHECK:           %[[C0:.*]] = constant 0 : index
 // CHECK:           %[[C1:.*]] = constant 1 : index
 // CHECK:           %[[MEMREF_ARG:.*]] = tensor_to_memref %[[ARG]] : memref<?x?xf32>
 // CHECK:           %[[DIM0:.*]] = dim %[[ARG]], %[[C0]] : tensor<?x?xf32>
 // CHECK:           %[[DIM1:.*]] = dim %[[ARG]], %[[C1]] : tensor<?x?xf32>
-// CHECK:           %[[RESULT0:.*]] = alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
-// CHECK:           %[[RESULT1:.*]] = alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
+// CHECK:           %[[RESULT0:.*]] = memref.alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
+// CHECK:           %[[RESULT1:.*]] = memref.alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
 // CHECK:           linalg.generic
 // CHECK-SAME:      ins(%[[MEMREF_ARG]] : memref<?x?xf32>)
 // CHECK-SAME:      outs(%[[RESULT0]], %[[RESULT1]] : memref<?x?xf32>, memref<?x?xf32>)
 func @dynamic_results(%arg0: tensor<?x?xf32>)
          -> (tensor<?x?xf32>, tensor<?x?xf32>) {
     %0, %1 = linalg.generic {
       indexing_maps = [#map_2d, #map_2d, #map_2d],
       iterator_types = ["parallel", "parallel"]

 
 // Check the bufferization of init tensors.
 
 // CHECK-LABEL:   func @generic_with_init_tensor(
 // CHECK-SAME:                                   %[[ARG0_TENSOR:.*]]: tensor<2x3x4xvector<3x4xi4>>,
 // CHECK-SAME:                                   %[[ARG1_TENSOR:.*]]: tensor<3x2xf32>) -> tensor<3x2xf32> {
 // CHECK:           %[[ARG0_MEMREF:.*]] = tensor_to_memref %[[ARG0_TENSOR]] : memref<2x3x4xvector<3x4xi4>>
 // CHECK:           %[[ARG1_MEMREF:.*]] = tensor_to_memref %[[ARG1_TENSOR]] : memref<3x2xf32>
-// CHECK:           %[[INIT_BUFFER:.*]] = alloc() : memref<3x2xf32>
+// CHECK:           %[[INIT_BUFFER:.*]] = memref.alloc() : memref<3x2xf32>
 // CHECK:           linalg.copy(%[[ARG1_MEMREF]], %[[INIT_BUFFER]]) : memref<3x2xf32>, memref<3x2xf32>
 // CHECK:           linalg.generic
 // CHECK-SAME:      ins(%[[ARG0_MEMREF]] : memref<2x3x4xvector<3x4xi4>>)
 // CHECK-SAME:      outs(%[[INIT_BUFFER]] : memref<3x2xf32>) {
 func @generic_with_init_tensor(%arg0: tensor<2x3x4xvector<3x4xi4>>,
   %arg1: tensor<3x2xf32>) -> (tensor<3x2xf32>) {
 
   %0 = linalg.generic #trait

 
 // CHECK-LABEL: func @bufferize_subtensor(
 //  CHECK-SAME:   %[[T:[0-9a-z]*]]: tensor<?x?xf32>
 func @bufferize_subtensor(%t : tensor<?x?xf32>) -> (tensor<2x3xf32>, tensor<2x?xf32>) {
   //      CHECK: %[[IDX:.*]] = call @make_index() : () -> index
   %i0 = call @make_index() : () -> index
 
   //      CHECK: %[[M0:.*]] = tensor_to_memref %[[T]] : memref<?x?xf32>
-  // CHECK-NEXT: %[[A0:.*]] = alloc() : memref<2x3xf32>
+  // CHECK-NEXT: %[[A0:.*]] = memref.alloc() : memref<2x3xf32>
   // CHECK-NEXT: %[[SM0:.*]] = subview %[[M0]][0, 0] [2, 3] [1, 1]
   // CHECK-SAME:   memref<?x?xf32> to memref<2x3xf32, #[[$MAP0]]>
   // CHECK-NEXT: linalg.copy(%[[SM0]], %[[A0]]) : memref<2x3xf32, #[[$MAP0]]>, memref<2x3xf32>
   // CHECK-NEXT: %[[RT0:.*]] = tensor_load %[[A0]] : memref<2x3xf32>
   %st0 = subtensor %t[0, 0][2, 3][1, 1] : tensor<?x?xf32> to tensor<2x3xf32>
 
   //      CHECK: %[[M1:.*]] = tensor_to_memref %[[T]] : memref<?x?xf32>
-  // CHECK-NEXT: %[[A1:.*]] = alloc(%[[IDX]]) : memref<2x?xf32>
+  // CHECK-NEXT: %[[A1:.*]] = memref.alloc(%[[IDX]]) : memref<2x?xf32>
   // CHECK-NEXT: %[[SM1:.*]] = subview %[[M1]][0, %[[IDX]]] [2, %[[IDX]]] [1, 2]
   // CHECK-SAME:   memref<?x?xf32> to memref<2x?xf32, #[[$MAP1]]>
   // CHECK-NEXT: linalg.copy(%[[SM1]], %[[A1]]) : memref<2x?xf32, #[[$MAP1]]>, memref<2x?xf32>
   // CHECK-NEXT: %[[RT1:.*]] = tensor_load %[[A1]] : memref<2x?xf32>
   %st1 = subtensor %t[0, %i0][2, %i0][1, 2] : tensor<?x?xf32> to tensor<2x?xf32>
 
   // CHECK-NEXT: return %[[RT0]], %[[RT1]]
   return %st0, %st1 : tensor<2x3xf32>, tensor<2x?xf32>
func @bufferize_subtensor_insert(%t : tensor<?x?xf32>, %st0 : tensor<2x3xf32>, %st1 : tensor<2x?xf32>) ->
   %i0 = call @make_index() : () -> index
   // CHECK: %[[IDX:.*]] = call @make_index() : () -> index
 
 
   // CHECK-DAG: %[[M0:.*]] = tensor_to_memref %[[T]] : memref<?x?xf32>
   // CHECK-DAG: %[[SM0:.*]] = tensor_to_memref %[[ST0]] : memref<2x3xf32>
   // CHECK-NEXT: %[[DIM0:.*]] = dim %[[T]], %[[C0]] : tensor<?x?xf32>
   // CHECK-NEXT: %[[DIM1:.*]] = dim %[[T]], %[[C1]] : tensor<?x?xf32>
-  // CHECK-NEXT: %[[M0_COPY:.*]] = alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
+  // CHECK-NEXT: %[[M0_COPY:.*]] = memref.alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
   // CHECK-NEXT: linalg.copy(%[[M0]], %[[M0_COPY]]) : memref<?x?xf32>, memref<?x?xf32>
   // CHECK-NEXT: %[[SUBVIEW0:.*]] = subview %[[M0_COPY]][0, 0] [2, 3] [1, 1]
   // CHECK-SAME:   memref<?x?xf32> to memref<2x3xf32, #[[$MAP0]]>
   // CHECK-NEXT: linalg.copy(%[[SM0]], %[[SUBVIEW0]]) : memref<2x3xf32>, memref<2x3xf32, #[[$MAP0]]>
   // CHECK-NEXT: %[[RT0:.*]] = tensor_load %[[M0_COPY]] : memref<?x?xf32>
   %t0 = subtensor_insert %st0 into %t[0, 0][2, 3][1, 1] : tensor<2x3xf32> into tensor<?x?xf32>
 
   //  CHECK-DAG: %[[M1:.*]] = tensor_to_memref %[[T]] : memref<?x?xf32>
   //  CHECK-DAG: %[[SM1:.*]] = tensor_to_memref %[[ST1]] : memref<2x?xf32>
-  // CHECK-NEXT: %[[M1_COPY:.*]] = alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
+  // CHECK-NEXT: %[[M1_COPY:.*]] = memref.alloc(%[[DIM0]], %[[DIM1]]) : memref<?x?xf32>
   // CHECK-NEXT: linalg.copy(%[[M1]], %[[M1_COPY]]) : memref<?x?xf32>, memref<?x?xf32>
   // CHECK-NEXT: %[[SUBVIEW1:.*]] = subview %[[M1_COPY]][0, %[[IDX]]] [2, %[[IDX]]] [1, 2]
   // CHECK-SAME:   memref<?x?xf32> to memref<2x?xf32, #[[$MAP1]]>
   // CHECK-NEXT: linalg.copy(%[[SM1]], %[[SUBVIEW1]]) : memref<2x?xf32>, memref<2x?xf32, #[[$MAP1]]>
   // CHECK-NEXT: %[[RT1:.*]] = tensor_load %[[M1_COPY]] : memref<?x?xf32>
   %t1 = subtensor_insert %st1 into %t[0, %i0][2, %i0][1, 2] : tensor<2x?xf32> into tensor<?x?xf32>
 
   //     CHECK: return %[[RT0]], %[[RT1]]
   return %t0, %t1: tensor<?x?xf32>, tensor<?x?xf32>
 }
 

mlir/test/Dialect/Linalg/canonicalize.mlir

 // RUN: mlir-opt %s -canonicalize -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @memref_cast(
 func @memref_cast(%a: index, %b: index) -> memref<?x?xf32> {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c8 = constant 8 : index
   %c16 = constant 16 : index
-  %1 = alloc (%b) : memref<?xi8>
-  %2 = view %1[%c0][] : memref<?xi8> to memref<16x16xf32>
-  %3 = memref_cast %2 : memref<16x16xf32> to memref<?x?xf32>
+  %1 = memref.alloc (%b) : memref<?xi8>
+  %2 = memref.view %1[%c0][] : memref<?xi8> to memref<16x16xf32>
+  %3 = memref.cast %2 : memref<16x16xf32> to memref<?x?xf32>
 
   // CHECK:  linalg.matmul ins({{.*}}memref<16x16xf32>, memref<16x16xf32>) outs({{.*}}memref<16x16xf32>)
   linalg.matmul ins(%3, %3: memref<?x?xf32>, memref<?x?xf32>)
                outs(%3: memref<?x?xf32>)
   return %3: memref<?x?xf32>
 }
 
 // -----

mlir/test/Dialect/Linalg/fold-affine-min-scf.mlir

 // RUN: mlir-opt %s -test-linalg-transform-patterns=test-affine-min-scf-canonicalization-patterns | FileCheck %s
 
 // CHECK-LABEL: scf_for
 func @scf_for(%A : memref<i64>, %step : index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c7 = constant 7 : index
   %c4 = constant 4 : index
   %c16 = constant 16 : index
   %c1024 = constant 1024 : index
 
   //      CHECK: scf.for
   // CHECK-NEXT:   %[[C2:.*]] = constant 2 : index
   // CHECK-NEXT:   %[[C2I64:.*]] = index_cast %[[C2:.*]]
-  // CHECK-NEXT:   store %[[C2I64]], %{{.*}}[] : memref<i64>
+  // CHECK-NEXT:   memref.store %[[C2I64]], %{{.*}}[] : memref<i64>
   scf.for %i = %c0 to %c4 step %c2 {
     %1 = affine.min affine_map<(d0, d1)[] -> (2, d1 - d0)> (%i, %c4)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   //      CHECK: scf.for
   // CHECK-NEXT:   %[[C2:.*]] = constant 2 : index
   // CHECK-NEXT:   %[[C2I64:.*]] = index_cast %[[C2:.*]]
-  // CHECK-NEXT:   store %[[C2I64]], %{{.*}}[] : memref<i64>
+  // CHECK-NEXT:   memref.store %[[C2I64]], %{{.*}}[] : memref<i64>
   scf.for %i = %c1 to %c7 step %c2 {
     %1 = affine.min affine_map<(d0)[s0] -> (s0 - d0, 2)> (%i)[%c7]
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This should not canonicalize because: 4 - %i may take the value 1 < 2.
   //     CHECK:   scf.for
   //     CHECK:     affine.min
   //     CHECK:     index_cast
   scf.for %i = %c1 to %c4 step %c2 {
     %1 = affine.min affine_map<(d0)[s0] -> (2, s0 - d0)> (%i)[%c4]
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This should not canonicalize because: 16 - %i may take the value 15 < 1024.
   //     CHECK:   scf.for
   //     CHECK:     affine.min
   //     CHECK:     index_cast
   scf.for %i = %c1 to %c16 step %c1024 {
     %1 = affine.min affine_map<(d0) -> (1024, 16 - d0)> (%i)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This example should simplify but affine_map is currently missing
   // semi-affine canonicalizations: `((s0 * 42 - 1) floordiv s0) * s0`
   // should evaluate to 41 * s0.
   // Note that this may require positivity assumptions on `s0`.
   // Revisit when support is added.
   // CHECK: scf.for
   // CHECK:   affine.min
   // CHECK:   index_cast
   %ub = affine.apply affine_map<(d0) -> (42 * d0)> (%step)
   scf.for %i = %c0 to %ub step %step {
     %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d1 - d2)> (%step, %ub, %i)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This example should simplify but affine_map is currently missing
   // semi-affine canonicalizations.
   // This example should simplify but affine_map is currently missing
   // semi-affine canonicalizations: ` -(((s0 * s0 - 1) floordiv s0) * s0)`
   // should evaluate to (s0 - 1) * s0.
   // Note that this may require positivity assumptions on `s0`.
   // Revisit when support is added.
   // CHECK: scf.for
   // CHECK:   affine.min
   // CHECK:   index_cast
   %ub2 = affine.apply affine_map<(d0)[s0] -> (s0 * d0)> (%step)[%step]
   scf.for %i = %c0 to %ub2 step %step {
     %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d2 - d1)> (%step, %i, %ub2)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   return
 }
 
 // CHECK-LABEL: scf_parallel
 func @scf_parallel(%A : memref<i64>, %step : index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c7 = constant 7 : index
   %c4 = constant 4 : index
 
   // CHECK: scf.parallel
   // CHECK-NEXT:   %[[C2:.*]] = constant 2 : index
   // CHECK-NEXT:   %[[C2I64:.*]] = index_cast %[[C2:.*]]
-  // CHECK-NEXT:   store %[[C2I64]], %{{.*}}[] : memref<i64>
+  // CHECK-NEXT:   memref.store %[[C2I64]], %{{.*}}[] : memref<i64>
   scf.parallel (%i) = (%c0) to (%c4) step (%c2) {
     %1 = affine.min affine_map<(d0, d1)[] -> (2, d1 - d0)> (%i, %c4)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // CHECK: scf.parallel
   // CHECK-NEXT:   %[[C2:.*]] = constant 2 : index
   // CHECK-NEXT:   %[[C2I64:.*]] = index_cast %[[C2:.*]]
-  // CHECK-NEXT:   store %[[C2I64]], %{{.*}}[] : memref<i64>
+  // CHECK-NEXT:   memref.store %[[C2I64]], %{{.*}}[] : memref<i64>
   scf.parallel (%i) = (%c1) to (%c7) step (%c2) {
     %1 = affine.min affine_map<(d0)[s0] -> (2, s0 - d0)> (%i)[%c7]
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This example should simplify but affine_map is currently missing
   // semi-affine canonicalizations.
   // This affine map does not currently evaluate to (0, 0):
   //   (d0)[s0] -> (s0 mod s0, (-((d0 floordiv s0) * s0) + s0 * 42) mod s0)
   // TODO: Revisit when support is added.
   // CHECK: scf.parallel
   // CHECK:   affine.min
   // CHECK:   index_cast
   %ub = affine.apply affine_map<(d0) -> (42 * d0)> (%step)
   scf.parallel (%i) = (%c0) to (%ub) step (%step) {
     %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d2 - d1)> (%step, %i, %ub)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   // This example should simplify but affine_map is currently missing
   // semi-affine canonicalizations.
   // This affine map does not currently evaluate to (0, 0):
   //   (d0)[s0] -> (s0 mod s0, (-((d0 floordiv s0) * s0) + s0 * s0) mod s0)
   // TODO: Revisit when support is added.
   // CHECK: scf.parallel
   // CHECK:   affine.min
   // CHECK:   index_cast
   %ub2 = affine.apply affine_map<(d0)[s0] -> (s0 * d0)> (%step)[%step]
   scf.parallel (%i) = (%c0) to (%ub2) step (%step) {
     %1 = affine.min affine_map<(d0, d1, d2) -> (d0, d2 - d1)> (%step, %i, %ub2)
     %2 = index_cast %1: index to i64
-    store %2, %A[]: memref<i64>
+    memref.store %2, %A[]: memref<i64>
   }
 
   return
 }

mlir/test/Dialect/Linalg/forward-vector-transfers.mlir

 // RUN: mlir-opt %s -allow-unregistered-dialect -test-linalg-transform-patterns=test-vector-transfer-forwarding-patterns | FileCheck %s
 
 // CHECK-LABEL: testAllocRead
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.fill
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_read %[[ARG0]]
 //   CHECK-NOT: masked
 func @testAllocRead(%in: memref<? x f32>) -> vector<32 x f32> {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<32 x f32>
+  %alloc = memref.alloc() : memref<32 x f32>
   %subview = subview %alloc[0][16][1] : memref<32 x f32> to memref<16 x f32>
   linalg.copy(%in, %subview): memref<? x f32>, memref<16 x f32>
   %0 = vector.transfer_read %alloc[%c0], %f0 {masked = [false]} : memref<32 x f32>, vector<32 x f32>
-  dealloc %alloc : memref<32 x f32>
+  memref.dealloc %alloc : memref<32 x f32>
   return %0: vector<32 x f32>
 }
 
 // CHECK-LABEL: testAllocFillRead
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.fill
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_read %[[ARG0]]
 //   CHECK-NOT: masked
 func @testAllocFillRead(%in: memref<? x f32>) -> vector<32 x f32> {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<32 x f32>
+  %alloc = memref.alloc() : memref<32 x f32>
   linalg.fill(%alloc, %f0): memref<32 x f32>, f32
   %subview = subview %alloc[0][16][1] : memref<32 x f32> to memref<16 x f32>
   linalg.copy(%in, %subview): memref<? x f32>, memref<16 x f32>
   %0 = vector.transfer_read %alloc[%c0], %f0 {masked = [false]} : memref<32 x f32>, vector<32 x f32>
-  dealloc %alloc : memref<32 x f32>
+  memref.dealloc %alloc : memref<32 x f32>
   return %0: vector<32 x f32>
 }
 
 // CHECK-LABEL: testViewRead
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.fill
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_read %[[ARG0]]
 //   CHECK-NOT: masked
 func @testViewRead(%in: memref<? x f32>) -> vector<32 x f32> {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<128 x i8>
-  %view = view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
+  %alloc = memref.alloc() : memref<128 x i8>
+  %view = memref.view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
   %subview = subview %view[0][16][1] : memref<32 x f32> to memref<16 x f32>
   linalg.copy(%in, %subview): memref<? x f32>, memref<16 x f32>
   %0 = vector.transfer_read %view[%c0], %f0 {masked = [false]} : memref<32 x f32>, vector<32 x f32>
-  dealloc %alloc : memref<128 x i8>
+  memref.dealloc %alloc : memref<128 x i8>
   return %0: vector<32 x f32>
 }
 
 // CHECK-LABEL: testViewFillRead
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.fill
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_read %[[ARG0]]
 //   CHECK-NOT: masked
 func @testViewFillRead(%in: memref<? x f32>) -> vector<32 x f32> {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<128 x i8>
-  %view = view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
+  %alloc = memref.alloc() : memref<128 x i8>
+  %view = memref.view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
   %subview = subview %view[0][16][1] : memref<32 x f32> to memref<16 x f32>
   linalg.fill(%view, %f0): memref<32 x f32>, f32
   linalg.copy(%in, %subview): memref<? x f32>, memref<16 x f32>
   %0 = vector.transfer_read %view[%c0], %f0 {masked = [false]} : memref<32 x f32>, vector<32 x f32>
-  dealloc %alloc : memref<128 x i8>
+  memref.dealloc %alloc : memref<128 x i8>
   return %0: vector<32 x f32>
 }
 
 // CHECK-LABEL: testAllocWrite
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: vector
 //  CHECK-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_write %[[ARG0]], %[[ARG1]]
 //   CHECK-NOT: masked
 func @testAllocWrite(%vec: vector<32 x f32>, %out: memref<? x f32>) {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<32 x f32>
+  %alloc = memref.alloc() : memref<32 x f32>
   %subview = subview %alloc[0][16][1] : memref<32 x f32> to memref<16 x f32>
   vector.transfer_write %vec, %alloc[%c0] {masked = [false]} : vector<32 x f32>, memref<32 x f32>
   linalg.copy(%subview, %out): memref<16 x f32>, memref<? x f32>
-  dealloc %alloc : memref<32 x f32>
+  memref.dealloc %alloc : memref<32 x f32>
   return
 }
 
 // CHECK-LABEL: testViewWrite
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: vector
 //  CHECK-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: linalg.copy
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_write %[[ARG0]], %[[ARG1]]
 //   CHECK-NOT: masked
 func @testViewWrite(%vec: vector<32 x f32>, %out: memref<? x f32>) {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<128 x i8>
-  %view = view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
+  %alloc = memref.alloc() : memref<128 x i8>
+  %view = memref.view %alloc[%c0][] : memref<128 x i8> to memref<32 x f32>
   %subview = subview %view[0][16][1] : memref<32 x f32> to memref<16 x f32>
   vector.transfer_write %vec, %view[%c0] {masked = [false]} : vector<32 x f32>, memref<32 x f32>
   linalg.copy(%subview, %out): memref<16 x f32>, memref<? x f32>
-  dealloc %alloc : memref<128 x i8>
+  memref.dealloc %alloc : memref<128 x i8>
   return
 }
 
 ///===--------------------------------------------------------------------===///
 // Negative tests
 ///===--------------------------------------------------------------------===///
 
 // This should fail the rewrite due to mismatching fill and transfer read value.
 // CHECK-LABEL: failAllocFillRead
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: vector.transfer_read %[[ARG0]]
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: linalg.copy
 //       CHECK: vector.transfer_read %[[ALLOC]]
 func @failAllocFillRead(%in: memref<? x f32>) -> vector<32 x f32> {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
   %f1 = constant 1.0: f32
-  %alloc = alloc() : memref<32 x f32>
+  %alloc = memref.alloc() : memref<32 x f32>
   linalg.fill(%alloc, %f0): memref<32 x f32>, f32
   %subview = subview %alloc[0][16][1] : memref<32 x f32> to memref<16 x f32>
   linalg.copy(%in, %subview): memref<? x f32>, memref<16 x f32>
   "some_interleaved_use"(%subview) : (memref<16 x f32>) -> ()
   %0 = vector.transfer_read %alloc[%c0], %f1: memref<32 x f32>, vector<32 x f32>
-  dealloc %alloc : memref<32 x f32>
+  memref.dealloc %alloc : memref<32 x f32>
   return %0: vector<32 x f32>
 }
 
 // This should fail the rewrite due to some interleaved use.
 // CHECK-LABEL: failAllocWrite
 //  CHECK-SAME: %[[ARG0:[0-9a-zA-Z]*]]: vector
 //  CHECK-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref
 //   CHECK-NOT: vector.transfer_write %[[ARG0]], %[[ARG1]]
-//       CHECK: %[[ALLOC:.*]] = alloc
+//       CHECK: %[[ALLOC:.*]] = memref.alloc
 //       CHECK: vector.transfer_write %[[ARG0]], %[[ALLOC]]
 //       CHECK: linalg.copy
 func @failAllocWrite(%vec: vector<32 x f32>, %out: memref<? x f32>) {
   %c0 = constant 0: index
   %f0 = constant 0.0: f32
-  %alloc = alloc() : memref<32 x f32>
+  %alloc = memref.alloc() : memref<32 x f32>
   %subview = subview %alloc[0][16][1] : memref<32 x f32> to memref<16 x f32>
   vector.transfer_write %vec, %alloc[%c0] : vector<32 x f32>, memref<32 x f32>
   "some_interleaved_use"(%subview) : (memref<16 x f32>) -> ()
   linalg.copy(%subview, %out): memref<16 x f32>, memref<? x f32>
-  dealloc %alloc : memref<32 x f32>
+  memref.dealloc %alloc : memref<32 x f32>
   return
 }

mlir/test/Dialect/Linalg/fusion-pattern.mlir

 
 module {
   func @matmul_plus_matmul(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
                            %arg2: memref<?x?xf32>) {
     %c0 = constant 0 : index
     %c1 = constant 1 : index
     %0 = dim %arg2, %c0 : memref<?x?xf32>
     %1 = dim %arg2, %c1 : memref<?x?xf32>
-    %2 = alloc(%0, %1) : memref<?x?xf32>
+    %2 = memref.alloc(%0, %1) : memref<?x?xf32>
     linalg.matmul ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%2 : memref<?x?xf32>)
     linalg.generic
       {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
                         affine_map<(d0, d1) -> (d0, d1)>,
                         affine_map<(d0, d1) -> (d0, d1)>],
        iterator_types = ["parallel", "parallel"],
        __internal_linalg_transform__ = "transpose_fusion"}
       ins(%2, %2 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%arg2 : memref<?x?xf32>) {
       ^bb0(%arg3 : f32, %arg4 : f32, %arg5 : f32) :
         %3 = addf %arg3, %arg4 : f32
         linalg.yield %3 : f32
       }
     return
   }
 }
 //       CHECK: func @matmul_plus_matmul
 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]+]]: memref<?x?xf32>
-//       CHECK:   %[[T2:.+]] = alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32>
+//       CHECK:   %[[T2:.+]] = memref.alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32>
 //       CHECK:   linalg.matmul
 //  CHECK-SAME:     after_transpose_fusion_original
 //       CHECK:   scf.parallel (%[[ARG3:[a-zA-Z0-9_]+]], %[[ARG4:.[a-zA-Z0-9_]+]])
 //       CHECK:     %[[T5:.+]] = subview %[[T2]][%[[ARG3]], %[[ARG4]]]
 //       CHECK:     %[[T6:.+]] = subview %[[ARG2]][%[[ARG3]], %[[ARG4]]]
 //       CHECK:     %[[T8:.+]] = subview %[[ARG0]][%[[ARG3]], 0]
 //       CHECK:     %[[T9:.+]] = subview %[[ARG1]][0, %[[ARG4]]]
 //       CHECK:     linalg.matmul

 module {
   func @matmul_plus_transpose_matmul(%arg0: memref<?x?xf32>,
                                      %arg1: memref<?x?xf32>,
                                      %arg2: memref<?x?xf32>) {
     %c0 = constant 0 : index
     %c1 = constant 1 : index
     %0 = dim %arg2, %c0 : memref<?x?xf32>
     %1 = dim %arg2, %c1 : memref<?x?xf32>
-    %2 = alloc(%0, %1) : memref<?x?xf32>
+    %2 = memref.alloc(%0, %1) : memref<?x?xf32>
     linalg.matmul ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%2 : memref<?x?xf32>)
     linalg.generic
       {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
                         affine_map<(d0, d1) -> (d1, d0)>,
                         affine_map<(d0, d1) -> (d0, d1)>],
        iterator_types = ["parallel", "parallel"],
        __internal_linalg_transform__ = "transpose_fusion"}

mlir/test/Dialect/Linalg/fusion-sequence.mlir

 // RUN: mlir-opt -pass-pipeline="func(test-linalg-tile-and-fuse{tile-sizes=16,32,64}),canonicalize,cse" -split-input-file %s | FileCheck %s
 
 module {
   func @three_op_fusion(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
                         %arg2: memref<?xf32>, %arg3 : memref<?x?xf32>) {
     %cst = constant 0.000000e+00 : f32
     %c0 = constant 0 : index
     %c1 = constant 1 : index
     %d0 = dim %arg0, %c0 : memref<?x?xf32>
     %d1 = dim %arg1, %c1 : memref<?x?xf32>
-    %0 = alloc(%d0, %d1) : memref<?x?xf32>
+    %0 = memref.alloc(%d0, %d1) : memref<?x?xf32>
     linalg.fill(%0, %cst) : memref<?x?xf32>, f32
     linalg.matmul ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%0 : memref<?x?xf32>)
     linalg.generic
       {indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>,
                         affine_map<(d0, d1) -> (d1)>,
                         affine_map<(d0, d1) -> (d0, d1)>],
        iterator_types = ["parallel", "parallel"]}

 
 //   CHECK-DAG: #[[MAP2:.+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 //   CHECK-DAG: #[[MAP3:.+]] = affine_map<(d0)[s0] -> (d0 + s0)>
 //       CHECK: func @three_op_fusion
 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]+]]: memref<?xf32>
 //  CHECK-SAME:   %[[ARG3:[a-zA-Z0-9_]+]]: memref<?x?xf32>
-//       CHECK:   %[[TEMP:.+]] = alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32>
+//       CHECK:   %[[TEMP:.+]] = memref.alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32>
 //       CHECK:   scf.parallel (%[[IV0:.+]], %[[IV1:.+]]) = {{.*}} {
 //   CHECK-DAG:     %[[SV_TEMP:.+]] = subview %[[TEMP]][%[[IV0]], %[[IV1]]]
 //   CHECK-DAG:     %[[SV_ARG2:.+]] = subview %[[ARG2]][%[[IV1]]]
 //   CHECK-DAG:     %[[SV_ARG3:.+]] = subview %[[ARG3]][%[[IV0]], %[[IV1]]]
 //   CHECK-DAG:     %[[SV_ARG0:.+]] = subview %[[ARG0]][%[[IV0]], 0]
 //   CHECK-DAG:     %[[SV_ARG1:.+]] = subview %[[ARG1]][0, %[[IV1]]]
 //       CHECK:     linalg.fill(%[[SV_TEMP]], %{{.+}})
 //       CHECK:     linalg.matmul
func @sequence_of_matmul(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>,
                            %arg4: memref<?x?xf32>) {
     %cst = constant 0.000000e+00 : f32
     %c0 = constant 0 : index
     %c1 = constant 1 : index
     %m = dim %arg0, %c0 : memref<?x?xf32>
     %n1 = dim %arg1, %c1 : memref<?x?xf32>
     %n2 = dim %arg2, %c1 : memref<?x?xf32>
     %n3 = dim %arg3, %c1 : memref<?x?xf32>
-    %0 = alloc(%m, %n1) : memref<?x?xf32>
-    %1 = alloc(%m, %n2) : memref<?x?xf32>
+    %0 = memref.alloc(%m, %n1) : memref<?x?xf32>
+    %1 = memref.alloc(%m, %n2) : memref<?x?xf32>
     linalg.fill(%0, %cst) : memref<?x?xf32>, f32
     linalg.matmul ins(%arg0, %arg1 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%0 : memref<?x?xf32>)
     linalg.fill(%1, %cst) : memref<?x?xf32>, f32
     linalg.matmul ins(%0, %arg2 : memref<?x?xf32>, memref<?x?xf32>)
       outs(%1 : memref<?x?xf32>)
     linalg.fill(%arg4, %cst) : memref<?x?xf32>, f32
     linalg.matmul ins(%1, %arg3 : memref<?x?xf32>, memref<?x?xf32>)

 //  CHECK-SAME:   %[[ARG3:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-SAME:   %[[ARG4:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //   CHECK-DAG:   %[[C0:.+]] = constant 0 : index
 //   CHECK-DAG:   %[[C1:.+]] = constant 1 : index
 //   CHECK-DAG:   %[[C16:.+]] = constant 16 : index
 //   CHECK-DAG:   %[[M:.+]] = dim %[[ARG0]], %[[C0]]
 //   CHECK-DAG:   %[[N1:.+]] = dim %[[ARG1]], %[[C1]]
 //   CHECK-DAG:   %[[N2:.+]] = dim %[[ARG2]], %[[C1]]
-//       CHECK:   %[[ALLOC1:.+]] = alloc(%[[M]], %[[N1]])
-//       CHECK:   %[[ALLOC2:.+]] = alloc(%[[M]], %[[N2]])
+//       CHECK:   %[[ALLOC1:.+]] = memref.alloc(%[[M]], %[[N1]])
+//       CHECK:   %[[ALLOC2:.+]] = memref.alloc(%[[M]], %[[N2]])
 //       CHECK:   scf.parallel (%[[IV0:.+]]) = (%[[C0]]) to (%[[M]])
 //  CHECK-SAME:     step (%[[C16]]) {
 //       CHECK:     %[[TILE_M:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M]]]
 //       CHECK:     %[[SV_ALLOC2:.+]] = subview %[[ALLOC2]][%[[IV0]], 0]
 //  CHECK-SAME:       [%[[TILE_M]], %[[N2]]]
 //       CHECK:     %[[M_2:.+]] = dim %[[ARG4]], %[[C0]]
 //       CHECK:     %[[TILE_M_2:.+]] = affine.min #[[MAP0]](%[[IV0]])[%[[M_2]]]
 //       CHECK:     %[[N3:.+]] = dim %[[ARG4]], %[[C1]]

mlir/test/Dialect/Linalg/fusion.mlir

#pointwise_2d_trait = {
   indexing_maps = [#id_2d, #id_2d, #id_2d],
   iterator_types = ["parallel", "parallel"]
 }
 func @pointwise_no_view(%M: index, %N: index) {
   %c1 = constant 1 : index
   %c0 = constant 0 : index
   %c3 = constant 3 : index
   %c2 = constant 2 : index
-  %A = alloc (%M, %N): memref<?x?xf32>
-  %B = alloc (%M, %N): memref<?x?xf32>
-  %C = alloc (%M, %N): memref<?x?xf32>
-  %D = alloc (%M, %N): memref<?x?xf32>
-  %E = alloc (%M, %N): memref<?x?xf32>
+  %A = memref.alloc (%M, %N): memref<?x?xf32>
+  %B = memref.alloc (%M, %N): memref<?x?xf32>
+  %C = memref.alloc (%M, %N): memref<?x?xf32>
+  %D = memref.alloc (%M, %N): memref<?x?xf32>
+  %E = memref.alloc (%M, %N): memref<?x?xf32>
   linalg.generic #pointwise_2d_trait
     ins(%A, %A : memref<?x?xf32>, memref<?x?xf32>)
    outs(%B : memref<?x?xf32>) {
   ^bb0(%e: f32, %arg5: f32, %arg6: f32):   // no predecessors
     %2 = addf %e, %arg5 : f32
     linalg.yield %2 : f32
   }
   %0 = dim %B, %c0 : memref<?x?xf32>

 #map1 = affine_map<(d0, d1) -> (d0, d1)>
 #map2 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 
 func @fusion_of_three(%arg0: memref<100x10xf32>,
                       %arg1: memref<100xf32>,
                       %arg2: memref<100x10xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %0 = alloc() {temp = true} : memref<100x10xf32>
+  %0 = memref.alloc() {temp = true} : memref<100x10xf32>
   linalg.generic {
     indexing_maps = [#map0, #map1],
     iterator_types = ["parallel", "parallel"]}
     ins(%arg1 : memref<100xf32>)
    outs(%0 : memref<100x10xf32>) {
       ^bb0(%arg3: f32, %arg4: f32): // no predecessors
         linalg.yield %arg3 : f32
       }
-  %1 = alloc() {temp = true} : memref<100x10xf32>
+  %1 = memref.alloc() {temp = true} : memref<100x10xf32>
   linalg.generic {
     indexing_maps = [#map1, #map1, #map1],
     iterator_types = ["parallel", "parallel"]}
     ins(%arg0, %0: memref<100x10xf32>, memref<100x10xf32>)
    outs(%1 : memref<100x10xf32>) {
       ^bb0(%arg3: f32, %arg4: f32, %arg5: f32): // no predecessors
         %2 = subf %arg3, %arg4 : f32
         linalg.yield %2 : f32
       }
-  dealloc %0 : memref<100x10xf32>
+  memref.dealloc %0 : memref<100x10xf32>
   %2 = dim %1, %c0 : memref<100x10xf32>
   %3 = dim %1, %c1 : memref<100x10xf32>
   %4 = dim %arg2, %c0 : memref<100x10xf32>
   %5 = dim %arg2, %c1 : memref<100x10xf32>
   scf.for %i = %c0 to %2 step %c1 {
     scf.for %j = %c0 to %3 step %c1 {
       %6 = std.subview %1[%i, %j][%c1, %c1][%c1, %c1] :
       memref<100x10xf32> to memref<?x?xf32, #map2>
       %7 = std.subview %arg2[%i, %j][%c1, %c1][%c1, %c1] :
       memref<100x10xf32> to memref<?x?xf32, #map2>
       linalg.generic {
         indexing_maps = [#map1, #map1],
         iterator_types = ["parallel", "parallel"]}
         ins(%6 : memref<?x?xf32, #map2>)
        outs(%7 : memref<?x?xf32, #map2>) {
           ^bb0(%arg3: f32, %arg4: f32):     // no predecessors
             %8 = math.exp %arg3 : f32
             linalg.yield %8 : f32
           }
     }
   }
- dealloc %1 : memref<100x10xf32>
+ memref.dealloc %1 : memref<100x10xf32>
  return
 }
 // CHECK-LABEL: func @fusion
 // CHECK-NOT: linalg.generic
 // CHECK:     scf.for
 // CHECK:       scf.for
 // CHECK-NOT: scf.for
 // CHECK:       linalg.generic

 // Test that different allocation-like ops are recognized and properly handled.
 func @accept_different_alloc_ops(%dim: index, %s0 : index, %s1: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c3 = constant 3 : index
   %c4 = constant 4 : index
 
-  %A = alloca(%dim, %dim)[%s0, %s1] : memref<?x?xf32, offset: 0, strides: [?, ?]>
-  %B = alloca(%dim, %dim)[%s0, %s1] : memref<?x?xf32, offset: 0, strides: [?, ?]>
-  %C = alloc(%dim, %dim)[%s0, %s1]  : memref<?x?xf32, offset: 0, strides: [?, ?]>
+  %A = memref.alloca(%dim, %dim)[%s0, %s1] : memref<?x?xf32, offset: 0, strides: [?, ?]>
+  %B = memref.alloca(%dim, %dim)[%s0, %s1] : memref<?x?xf32, offset: 0, strides: [?, ?]>
+  %C = memref.alloc(%dim, %dim)[%s0, %s1]  : memref<?x?xf32, offset: 0, strides: [?, ?]>
 
   linalg.matmul ins(%A, %B : memref<?x?xf32, offset: 0, strides: [?, ?]>,
                              memref<?x?xf32, offset: 0, strides: [?, ?]>)
                outs(%C : memref<?x?xf32, offset: 0, strides: [?, ?]>)
 
   scf.for %i = %c0 to %dim step %c2 {
     scf.for %j = %c0 to %dim step %c3 {
       scf.for %k = %c0 to %dim step %c4 {

mlir/test/Dialect/Linalg/hoisting.mlir

 // RUN: mlir-opt %s -test-linalg-hoisting=test-hoist-view-allocs -allow-unregistered-dialect -split-input-file | FileCheck %s
 // RUN: mlir-opt %s -test-linalg-hoisting=test-hoist-redundant-transfers -allow-unregistered-dialect -split-input-file | FileCheck %s --check-prefix=VECTOR_TRANSFERS
 
 // -----
 
 // CHECK-LABEL: func @hoist_allocs(
 //  CHECK-SAME:   %[[VAL:[a-zA-Z0-9]*]]: index,
 //  CHECK-SAME:   %[[LB:[a-zA-Z0-9]*]]: index,
 //  CHECK-SAME:   %[[UB:[a-zA-Z0-9]*]]: index,
 //  CHECK-SAME:   %[[STEP:[a-zA-Z0-9]*]]: index,
 //  CHECK-SAME:   %[[CMP:[a-zA-Z0-9]*]]: i1
 func @hoist_allocs(%val: index, %lb : index, %ub : index, %step: index, %cmp: i1) {
-//   CHECK-DAG:   alloca(%[[VAL]]) : memref<?xi8>
-//   CHECK-DAG: %[[A0:.*]] = alloc(%[[VAL]]) : memref<?xi8>
+//   CHECK-DAG:   memref.alloca(%[[VAL]]) : memref<?xi8>
+//   CHECK-DAG: %[[A0:.*]] = memref.alloc(%[[VAL]]) : memref<?xi8>
 //       CHECK: scf.for %[[I:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] {
-//       CHECK:   alloca(%[[I]]) : memref<?xi8>
-//       CHECK:   %[[A1:.*]] = alloc(%[[I]]) : memref<?xi8>
+//       CHECK:   memref.alloca(%[[I]]) : memref<?xi8>
+//       CHECK:   %[[A1:.*]] = memref.alloc(%[[I]]) : memref<?xi8>
 //       CHECK:   scf.for %[[J:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] {
-//   CHECK-DAG:     alloca(%[[J]]) : memref<?xi8>
-//   CHECK-DAG:     %[[A2:.*]] = alloc(%[[J]]) : memref<?xi8>
+//   CHECK-DAG:     memref.alloca(%[[J]]) : memref<?xi8>
+//   CHECK-DAG:     %[[A2:.*]] = memref.alloc(%[[J]]) : memref<?xi8>
 //       CHECK:     scf.for %[[K:.*]] = %[[LB]] to %[[UB]] step %[[STEP]] {
   scf.for %i = %lb to %ub step %step {
     scf.for %j = %lb to %ub step %step {
       scf.for %k = %lb to %ub step %step {
         // Hoist allocs / deallocs outermost, keep view/subview below k.
-        %sa0 = alloca(%val) : memref<? x i8>
-        %a0 = alloc(%val) : memref<? x i8>
-//       CHECK:       std.view %[[A0]][%[[LB]]][] : memref<?xi8> to memref<16xf32>
+        %sa0 = memref.alloca(%val) : memref<? x i8>
+        %a0 = memref.alloc(%val) : memref<? x i8>
+//       CHECK:       memref.view %[[A0]][%[[LB]]][] : memref<?xi8> to memref<16xf32>
 //       CHECK:       subview %[[A0]][0] [42] [1]  : memref<?xi8> to memref<42xi8>
-        %v0 = view %a0[%lb][] : memref<? x i8> to memref<16 x f32>
+        %v0 = memref.view %a0[%lb][] : memref<? x i8> to memref<16 x f32>
         %sv0 = subview %a0[0][42][1] : memref<? x i8> to memref<42 x i8>
-        dealloc %a0 : memref<? x i8>
+        memref.dealloc %a0 : memref<? x i8>
 
         // Hoist below i.
-        %sa1 = alloca(%i) : memref<? x i8>
-        %a1 = alloc(%i) : memref<? x i8>
-        dealloc %a1 : memref<? x i8>
+        %sa1 = memref.alloca(%i) : memref<? x i8>
+        %a1 = memref.alloc(%i) : memref<? x i8>
+        memref.dealloc %a1 : memref<? x i8>
 
         // Hoist below j.
-        %sa2 = alloca(%j) : memref<? x i8>
-        %a2 = alloc(%j) : memref<? x i8>
-        dealloc %a2 : memref<? x i8>
+        %sa2 = memref.alloca(%j) : memref<? x i8>
+        %a2 = memref.alloc(%j) : memref<? x i8>
+        memref.dealloc %a2 : memref<? x i8>
 
         // Don't hoist since k innermost.
-//       CHECK:       alloca(%[[K]]) : memref<?xi8>
-//       CHECK:       %[[A3:.*]] = alloc(%[[K]]) : memref<?xi8>
-//       CHECK:       dealloc %[[A3]] : memref<?xi8>
-        %sa3 = alloca(%k) : memref<? x i8>
-        %a3 = alloc(%k) : memref<? x i8>
-        dealloc %a3 : memref<? x i8>
+//       CHECK:       memref.alloca(%[[K]]) : memref<?xi8>
+//       CHECK:       %[[A3:.*]] = memref.alloc(%[[K]]) : memref<?xi8>
+//       CHECK:       memref.dealloc %[[A3]] : memref<?xi8>
+        %sa3 = memref.alloca(%k) : memref<? x i8>
+        %a3 = memref.alloc(%k) : memref<? x i8>
+        memref.dealloc %a3 : memref<? x i8>
 
         // No hoisting due to control flow.
 //       CHECK:       scf.if %[[CMP]] {
-//       CHECK:         alloca(%[[VAL]]) : memref<?xi8>
-//       CHECK:         %[[A4:.*]] = alloc(%[[VAL]]) : memref<?xi8>
-//       CHECK:         dealloc %[[A4]] : memref<?xi8>
+//       CHECK:         memref.alloca(%[[VAL]]) : memref<?xi8>
+//       CHECK:         %[[A4:.*]] = memref.alloc(%[[VAL]]) : memref<?xi8>
+//       CHECK:         memref.dealloc %[[A4]] : memref<?xi8>
         scf.if %cmp {
-          %sa4 = alloca(%val) : memref<? x i8>
-          %a4 = alloc(%val) : memref<? x i8>
-          dealloc %a4 : memref<? x i8>
+          %sa4 = memref.alloca(%val) : memref<? x i8>
+          %a4 = memref.alloc(%val) : memref<? x i8>
+          memref.dealloc %a4 : memref<? x i8>
         }
 
         // No hoisting due to load/store.
-//       CHECK:       %[[SA5:.*]] = alloca(%[[VAL]]) : memref<?xi8>
-//       CHECK:       %[[A5:.*]] = alloc(%[[VAL]]) : memref<?xi8>
+//       CHECK:       %[[SA5:.*]] = memref.alloca(%[[VAL]]) : memref<?xi8>
+//       CHECK:       %[[A5:.*]] = memref.alloc(%[[VAL]]) : memref<?xi8>
 //       CHECK:       load %[[A5]][%[[LB]]] : memref<?xi8>
-//       CHECK:       store %{{.*}}, %[[SA5]][%[[LB]]] : memref<?xi8>
-//       CHECK:       dealloc %[[A5]] : memref<?xi8>
-        %sa5 = alloca(%val) : memref<? x i8>
-        %a5 = alloc(%val) : memref<? x i8>
+//       CHECK:       memref.store %{{.*}}, %[[SA5]][%[[LB]]] : memref<?xi8>
+//       CHECK:       memref.dealloc %[[A5]] : memref<?xi8>
+        %sa5 = memref.alloca(%val) : memref<? x i8>
+        %a5 = memref.alloc(%val) : memref<? x i8>
         %v5 = load %a5[%lb] : memref<? x i8>
-        store %v5, %sa5[%lb] : memref<? x i8>
-        dealloc %a5 : memref<? x i8>
+        memref.store %v5, %sa5[%lb] : memref<? x i8>
+        memref.dealloc %a5 : memref<? x i8>
 
       }
     }
   }
 //       CHECK:     }
-//       CHECK:     dealloc %[[A2]] : memref<?xi8>
+//       CHECK:     memref.dealloc %[[A2]] : memref<?xi8>
 //       CHECK:   }
-//       CHECK:   dealloc %[[A1]] : memref<?xi8>
+//       CHECK:   memref.dealloc %[[A1]] : memref<?xi8>
 //       CHECK: }
-//       CHECK: dealloc %[[A0]] : memref<?xi8>
+//       CHECK: memref.dealloc %[[A0]] : memref<?xi8>
   return
 }
 
 // -----
 
 // VECTOR_TRANSFERS-LABEL: func @hoist_vector_transfer_pairs(
 //  VECTOR_TRANSFERS-SAME:   %[[MEMREF0:[a-zA-Z0-9]*]]: memref<?x?xf32>,
 //  VECTOR_TRANSFERS-SAME:   %[[MEMREF1:[a-zA-Z0-9]*]]: memref<?x?xf32>,

mlir/test/Dialect/Linalg/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 func @load_number_of_indices(%v : memref<f32>) {
   // expected-error @+2 {{incorrect number of indices for load}}
   %c0 = constant 0 : index
   load %v[%c0] : memref<f32>
 }
 
 // -----
 
 func @store_number_of_indices(%v : memref<f32>) {
   // expected-error @+3 {{store index operand count not equal to memref rank}}
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
-  store %f0, %v[%c0] : memref<f32>
+  memref.store %f0, %v[%c0] : memref<f32>
 }
 
 // -----
 
 func @yield_parent(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected parent op with LinalgOp interface}}
   linalg.yield %arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }

mlir/test/Dialect/Linalg/loops.mlir

 // CHECKPARALLEL-DAG: #[[$stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
 // CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding1:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 1)>
 // CHECKPARALLEL-DAG: #[[$stride1Dilation1Padding2:.*]] = affine_map<(d0, d1) -> (d0 + d1 - 2)>
 
 
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %A = view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
-  %B = view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
-  %C = view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
+  %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
+  %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
   linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
                outs(%C: memref<?x?xf32>)
   return
 }
 // CHECKLOOP-LABEL: func @matmul(%{{.*}}: memref<?xi8>,
 //  CHECKLOOP-SAME: [[M:arg[0-9]+]]: index
 //  CHECKLOOP-SAME: [[N:arg[0-9]+]]: index
 //  CHECKLOOP-SAME: [[K:arg[0-9]+]]: index
-//       CHECKLOOP: %[[A:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKLOOP: %[[B:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKLOOP: %[[C:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKLOOP: %[[A:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKLOOP: %[[B:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKLOOP: %[[C:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECKLOOP: scf.for %{{.*}} = %{{.*}} to %[[M]] step %{{.*}} {
 //       CHECKLOOP:   scf.for %{{.*}} = %{{.*}} to %[[N]] step %{{.*}} {
 //       CHECKLOOP:     scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKLOOP-DAG:       %[[a:.*]] = load %[[A]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKLOOP-DAG:       %[[b:.*]] = load %[[B]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKLOOP-DAG:       %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKLOOP-DAG:       %[[c:.*]] = load %[[C]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKLOOP-DAG:       %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKLOOP:       store %[[res]], %[[C]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 
 // CHECKPARALLEL-LABEL: func @matmul(%{{.*}}: memref<?xi8>,
 //  CHECKPARALLEL-SAME: [[M:arg[0-9]+]]: index
 //  CHECKPARALLEL-SAME: [[N:arg[0-9]+]]: index
 //  CHECKPARALLEL-SAME: [[K:arg[0-9]+]]: index
-//       CHECKPARALLEL: %[[A:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKPARALLEL: %[[B:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKPARALLEL: %[[C:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKPARALLEL: %[[A:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKPARALLEL: %[[B:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKPARALLEL: %[[C:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECKPARALLEL: scf.parallel (%{{.*}}, %{{.*}}) = (%{{.*}}, %{{.*}}) to (%[[M]], %[[N]]) step (%{{.*}}, %{{.*}} {
 //       CHECKPARALLEL:   scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKPARALLEL-DAG:     %[[a:.*]] = load %[[A]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKPARALLEL-DAG:     %[[b:.*]] = load %[[B]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKPARALLEL-DAG:     %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKPARALLEL-DAG:     %[[c:.*]] = load %[[C]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKPARALLEL-DAG:     %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKPARALLEL:     store %[[res]], %[[C]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 
 
 
 func @matvec(%arg0: memref<?xi8>, %M: index, %N: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %2 = view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
-  %3 = view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
-  %4 = view %arg0[%c0][%N] : memref<?xi8> to memref<?xf32>
+  %2 = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  %3 = memref.view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
+  %4 = memref.view %arg0[%c0][%N] : memref<?xi8> to memref<?xf32>
   linalg.matvec ins(%2, %3: memref<?x?xf32>, memref<?xf32>)
                outs(%4 : memref<?xf32>)
   return
 }
 // CHECKLOOP-LABEL: func @matvec(%{{.*}}: memref<?xi8>,
 //  CHECKLOOP-SAME: [[M:arg[0-9]+]]: index
 //  CHECKLOOP-SAME: [[K:arg[0-9]+]]: index
-//       CHECKLOOP: %[[A:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKLOOP: %[[B:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKLOOP: %[[C:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKLOOP: %[[A:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKLOOP: %[[B:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKLOOP: %[[C:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
 //       CHECKLOOP: scf.for %{{.*}} = %{{.*}} to %[[M]] step %{{.*}} {
 //       CHECKLOOP:   scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKLOOP-DAG:     %[[a:.*]] = load %[[A]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKLOOP-DAG:     %[[b:.*]] = load %[[B]][%{{.*}}] : memref<?xf32>
 //   CHECKLOOP-DAG:     %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKLOOP-DAG:     %[[c:.*]] = load %[[C]][%{{.*}}] : memref<?xf32>
 //   CHECKLOOP-DAG:     %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKLOOP:     store %[[res]], %[[C]][%{{.*}}] : memref<?xf32>
 
 // CHECKPARALLEL-LABEL: func @matvec(%{{.*}}: memref<?xi8>,
 //  CHECKPARALLEL-SAME: [[M:arg[0-9]+]]: index
 //  CHECKPARALLEL-SAME: [[K:arg[0-9]+]]: index
-//       CHECKPARALLEL: %[[A:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
-//       CHECKPARALLEL: %[[B:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKPARALLEL: %[[C:.*]] = std.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKPARALLEL: %[[A:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECKPARALLEL: %[[B:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKPARALLEL: %[[C:.*]] = memref.view %{{.*}}[{{.*}}] : memref<?xi8> to memref<?xf32>
 //       CHECKPARALLEL: scf.parallel (%{{.*}}) = (%{{.*}}) to (%[[M]]) step (%{{.*}}) {
 //       CHECKPARALLEL:   scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKPARALLEL-DAG:     %[[a:.*]] = load %[[A]][%{{.*}}, %{{.*}}] : memref<?x?xf32>
 //   CHECKPARALLEL-DAG:     %[[b:.*]] = load %[[B]][%{{.*}}] : memref<?xf32>
 //   CHECKPARALLEL-DAG:     %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKPARALLEL-DAG:     %[[c:.*]] = load %[[C]][%{{.*}}] : memref<?xf32>
 //   CHECKPARALLEL-DAG:     %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKPARALLEL:     store %[[res]], %[[C]][%{{.*}}] : memref<?xf32>
 
 
 func @dot(%arg0: memref<?xi8>, %M: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %1 = view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
-  %2 = view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
-  %3 = view %arg0[%c0][] : memref<?xi8> to memref<f32>
+  %1 = memref.view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
+  %2 = memref.view %arg0[%c0][%M] : memref<?xi8> to memref<?xf32>
+  %3 = memref.view %arg0[%c0][] : memref<?xi8> to memref<f32>
   linalg.dot ins(%1, %2 : memref<?xf32>, memref<?xf32>)
             outs(%3 : memref<f32>)
   return
 }
 // CHECKLOOP-LABEL: func @dot(%{{.*}}: memref<?xi8>,
 //  CHECKLOOP-SAME: [[K:arg[0-9]+]]: index
-//       CHECKLOOP: %[[A:.*]] = std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKLOOP: %[[B:.*]] = std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKLOOP: %[[C:.*]] = std.view %{{.*}}[{{.*}}][] : memref<?xi8> to memref<f32>
+//       CHECKLOOP: %[[A:.*]] = memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKLOOP: %[[B:.*]] = memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKLOOP: %[[C:.*]] = memref.view %{{.*}}[{{.*}}][] : memref<?xi8> to memref<f32>
 //       CHECKLOOP: scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKLOOP-DAG:   %[[a:.*]] = load %[[A]][%{{.*}}] : memref<?xf32>
 //   CHECKLOOP-DAG:   %[[b:.*]] = load %[[B]][%{{.*}}] : memref<?xf32>
 //   CHECKLOOP-DAG:   %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKLOOP-DAG:   %[[c:.*]] = load %[[C]][] : memref<f32>
 //   CHECKLOOP-DAG:   %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKLOOP:   store %[[res]], %[[C]][] : memref<f32>
 
 // CHECKPARALLEL-LABEL: func @dot(%{{.*}}: memref<?xi8>,
 //  CHECKPARALLEL-SAME: [[K:arg[0-9]+]]: index
-//       CHECKPARALLEL: %[[A:.*]] = std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKPARALLEL: %[[B:.*]] = std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
-//       CHECKPARALLEL: %[[C:.*]] = std.view %{{.*}}[{{.*}}][] : memref<?xi8> to memref<f32>
+//       CHECKPARALLEL: %[[A:.*]] = memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKPARALLEL: %[[B:.*]] = memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?xf32>
+//       CHECKPARALLEL: %[[C:.*]] = memref.view %{{.*}}[{{.*}}][] : memref<?xi8> to memref<f32>
 //       CHECKPARALLEL: scf.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
 //   CHECKPARALLEL-DAG:   %[[a:.*]] = load %[[A]][%{{.*}}] : memref<?xf32>
 //   CHECKPARALLEL-DAG:   %[[b:.*]] = load %[[B]][%{{.*}}] : memref<?xf32>
 //   CHECKPARALLEL-DAG:   %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
 //   CHECKPARALLEL-DAG:   %[[c:.*]] = load %[[C]][] : memref<f32>
 //   CHECKPARALLEL-DAG:   %[[res:.*]] = addf %[[c]], %[[inc]] : f32
 //       CHECKPARALLEL:   store %[[res]], %[[C]][] : memref<f32>
 

mlir/test/Dialect/Linalg/promote.mlir

 // RUN: mlir-opt %s -linalg-promote-subviews | FileCheck %s
 // RUN: mlir-opt %s -linalg-promote-subviews="test-promote-dynamic" | FileCheck %s --check-prefix=DYNAMIC
 // RUN: mlir-opt %s -linalg-promote-subviews="test-use-alloca" | FileCheck %s --check-prefix=ALLOCA
 
 #map1 = affine_map<(d0) -> (d0 + 2)>
 #map2 = affine_map<(d0) -> (d0 + 4)>
 #map3 = affine_map<(d0) -> (d0 + 3)>
 
 // CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 
 func @matmul_f32(%A: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c4 = constant 4 : index
   %c3 = constant 3 : index
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %3 = view %A[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
-  %4 = view %A[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
-  %5 = view %A[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  %3 = memref.view %A[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
+  %4 = memref.view %A[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
+  %5 = memref.view %A[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
   %6 = dim %3, %c0 : memref<?x?xf32>
   %7 = dim %3, %c1 : memref<?x?xf32>
   %8 = dim %4, %c1 : memref<?x?xf32>
   scf.for %arg4 = %c0 to %6 step %c2 {
     scf.for %arg5 = %c0 to %8 step %c3 {
       scf.for %arg6 = %c0 to %7 step %c4 {
         %11 = std.subview %3[%arg4, %arg6][%c2, %c4][1, 1] : memref<?x?xf32> to memref<?x?xf32, offset: ?, strides: [?, 1]>
         %14 = std.subview %4[%arg6, %arg5][%c4, %c3][1, 1] : memref<?x?xf32> to memref<?x?xf32, offset: ?, strides: [?, 1]>

 // CHECK-LABEL: func @matmul_f32(%{{.*}}: memref<?xi8>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //       CHECK:   scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:     scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:       scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:         %[[vA:.*]] = subview {{.*}} : memref<?x?xf32>
 //       CHECK:         %[[vB:.*]] = subview {{.*}} : memref<?x?xf32>
 //       CHECK:         %[[vC:.*]] = subview {{.*}} : memref<?x?xf32>
 ///
-//       CHECK:         %[[tmpA:.*]] = alloc() : memref<32xi8>
-//      ALLOCA:         %[[tmpA:.*]] = alloca() : memref<32xi8>
-//       CHECK:         %[[fullA:.*]] = std.view %[[tmpA]][{{.*}}][{{.*}}] : memref<32xi8> to memref<?x?xf32>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK:         %[[tmpA:.*]] = memref.alloc() : memref<32xi8>
+//      ALLOCA:         %[[tmpA:.*]] = memref.alloca() : memref<32xi8>
+//       CHECK:         %[[fullA:.*]] = memref.view %[[tmpA]][{{.*}}][{{.*}}] : memref<32xi8> to memref<?x?xf32>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECK:         %[[partialA:.*]] = subview %[[fullA]]{{.*}} : memref<?x?xf32> to memref<?x?xf32, #[[$strided2D]]>
 ///
-//       CHECK:         %[[tmpB:.*]] = alloc() : memref<48xi8>
-//      ALLOCA:         %[[tmpB:.*]] = alloca() : memref<48xi8>
-//       CHECK:         %[[fullB:.*]] = std.view %[[tmpB]][{{.*}}][{{.*}}] : memref<48xi8> to memref<?x?xf32>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK:         %[[tmpB:.*]] = memref.alloc() : memref<48xi8>
+//      ALLOCA:         %[[tmpB:.*]] = memref.alloca() : memref<48xi8>
+//       CHECK:         %[[fullB:.*]] = memref.view %[[tmpB]][{{.*}}][{{.*}}] : memref<48xi8> to memref<?x?xf32>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECK:         %[[partialB:.*]] = subview %[[fullB]]{{.*}} : memref<?x?xf32> to memref<?x?xf32, #[[$strided2D]]>
 ///
-//       CHECK:         %[[tmpC:.*]] = alloc() : memref<24xi8>
-//      ALLOCA:         %[[tmpC:.*]] = alloca() : memref<24xi8>
-//       CHECK:         %[[fullC:.*]] = std.view %[[tmpC]][{{.*}}][{{.*}}] : memref<24xi8> to memref<?x?xf32>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
+//       CHECK:         %[[tmpC:.*]] = memref.alloc() : memref<24xi8>
+//      ALLOCA:         %[[tmpC:.*]] = memref.alloca() : memref<24xi8>
+//       CHECK:         %[[fullC:.*]] = memref.view %[[tmpC]][{{.*}}][{{.*}}] : memref<24xi8> to memref<?x?xf32>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf32>
 //       CHECK:         %[[partialC:.*]] = subview %[[fullC]]{{.*}} : memref<?x?xf32> to memref<?x?xf32, #[[$strided2D]]>
 
 //       CHECK:         linalg.copy(%[[vA]], %[[partialA]]) : memref<?x?xf32, #[[$strided2D]]>, memref<?x?xf32, #[[$strided2D]]>
 //       CHECK:         linalg.copy(%[[vB]], %[[partialB]]) : memref<?x?xf32, #[[$strided2D]]>, memref<?x?xf32, #[[$strided2D]]>
 //       CHECK:         linalg.copy(%[[vC]], %[[partialC]]) : memref<?x?xf32, #[[$strided2D]]>, memref<?x?xf32, #[[$strided2D]]>
 //
 //       CHECK:         linalg.matmul ins(%[[partialA]], %[[partialB]]{{.*}} outs(%[[partialC]]
 //
 //       CHECK:         linalg.copy(%[[partialC]], %[[vC]]) :
 //       CHECK:           memref<?x?xf32, #[[$strided2D]]>,
 //       CHECK:           memref<?x?xf32, #[[$strided2D]]>
 //
-//       CHECK:         dealloc %[[tmpA]] : memref<32xi8>
-//       CHECK:         dealloc %[[tmpB]] : memref<48xi8>
-//       CHECK:         dealloc %[[tmpC]] : memref<24xi8>
-//  ALLOCA-NOT:         dealloc %[[tmpA]] : memref<32xi8>
-//  ALLOCA-NOT:         dealloc %[[tmpB]] : memref<48xi8>
-//  ALLOCA-NOT:         dealloc %[[tmpC]] : memref<24xi8>
+//       CHECK:         memref.dealloc %[[tmpA]] : memref<32xi8>
+//       CHECK:         memref.dealloc %[[tmpB]] : memref<48xi8>
+//       CHECK:         memref.dealloc %[[tmpC]] : memref<24xi8>
+//  ALLOCA-NOT:         memref.dealloc %[[tmpA]] : memref<32xi8>
+//  ALLOCA-NOT:         memref.dealloc %[[tmpB]] : memref<48xi8>
+//  ALLOCA-NOT:         memref.dealloc %[[tmpC]] : memref<24xi8>
 
 // -----
 
 func @matmul_f64(%A: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c4 = constant 4 : index
   %c3 = constant 3 : index
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %3 = view %A[%c0][%M, %K] : memref<?xi8> to memref<?x?xf64>
-  %4 = view %A[%c0][%K, %N] : memref<?xi8> to memref<?x?xf64>
-  %5 = view %A[%c0][%M, %N] : memref<?xi8> to memref<?x?xf64>
+  %3 = memref.view %A[%c0][%M, %K] : memref<?xi8> to memref<?x?xf64>
+  %4 = memref.view %A[%c0][%K, %N] : memref<?xi8> to memref<?x?xf64>
+  %5 = memref.view %A[%c0][%M, %N] : memref<?xi8> to memref<?x?xf64>
   %6 = dim %3, %c0 : memref<?x?xf64>
   %7 = dim %3, %c1 : memref<?x?xf64>
   %8 = dim %4, %c1 : memref<?x?xf64>
   scf.for %arg4 = %c0 to %6 step %c2 {
     scf.for %arg5 = %c0 to %8 step %c3 {
       scf.for %arg6 = %c0 to %7 step %c4 {
         %11 = std.subview %3[%arg4, %arg6][%c2, %c4][1, 1] : memref<?x?xf64> to memref<?x?xf64, offset: ?, strides: [?, 1]>
         %14 = std.subview %4[%arg6, %arg5][%c4, %c3][1, 1] : memref<?x?xf64> to memref<?x?xf64, offset: ?, strides: [?, 1]>

 // CHECK-LABEL: func @matmul_f64(%{{.*}}: memref<?xi8>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //       CHECK:   scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:     scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:       scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:         %[[vA_f64:.*]] = subview {{.*}} : memref<?x?xf64>
 //       CHECK:         %[[vB_f64:.*]] = subview {{.*}} : memref<?x?xf64>
 //       CHECK:         %[[vC_f64:.*]] = subview {{.*}} : memref<?x?xf64>
 ///
-//       CHECK:         %[[tmpA_f64:.*]] = alloc() : memref<64xi8>
-//       CHECK:         %[[fullA_f64:.*]] = std.view %[[tmpA_f64]][{{.*}}][{{.*}}] : memref<64xi8> to memref<?x?xf64>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
+//       CHECK:         %[[tmpA_f64:.*]] = memref.alloc() : memref<64xi8>
+//       CHECK:         %[[fullA_f64:.*]] = memref.view %[[tmpA_f64]][{{.*}}][{{.*}}] : memref<64xi8> to memref<?x?xf64>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
 //       CHECK:         %[[partialA_f64:.*]] = subview %[[fullA_f64]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf64> to memref<?x?xf64, #[[$strided2D]]>
 ///
-//       CHECK:         %[[tmpB_f64:.*]] = alloc() : memref<96xi8>
-//       CHECK:         %[[fullB_f64:.*]] = std.view %[[tmpB_f64]][{{.*}}][{{.*}}] : memref<96xi8> to memref<?x?xf64>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
+//       CHECK:         %[[tmpB_f64:.*]] = memref.alloc() : memref<96xi8>
+//       CHECK:         %[[fullB_f64:.*]] = memref.view %[[tmpB_f64]][{{.*}}][{{.*}}] : memref<96xi8> to memref<?x?xf64>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
 //       CHECK:         %[[partialB_f64:.*]] = subview %[[fullB_f64]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf64> to memref<?x?xf64, #[[$strided2D]]>
 ///
-//       CHECK:         %[[tmpC_f64:.*]] = alloc() : memref<48xi8>
-//       CHECK:         %[[fullC_f64:.*]] = std.view %[[tmpC_f64]][{{.*}}][{{.*}}] : memref<48xi8> to memref<?x?xf64>
-//     DYNAMIC:         std.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
+//       CHECK:         %[[tmpC_f64:.*]] = memref.alloc() : memref<48xi8>
+//       CHECK:         %[[fullC_f64:.*]] = memref.view %[[tmpC_f64]][{{.*}}][{{.*}}] : memref<48xi8> to memref<?x?xf64>
+//     DYNAMIC:         memref.view %{{.*}}[{{.*}}][{{.*}}] : memref<?xi8> to memref<?x?xf64>
 //       CHECK:         %[[partialC_f64:.*]] = subview %[[fullC_f64]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf64> to memref<?x?xf64, #[[$strided2D]]>
 
 //       CHECK:         linalg.copy(%[[vA_f64]], %[[partialA_f64]]) : memref<?x?xf64, #[[$strided2D]]>, memref<?x?xf64, #[[$strided2D]]>
 //       CHECK:         linalg.copy(%[[vB_f64]], %[[partialB_f64]]) : memref<?x?xf64, #[[$strided2D]]>, memref<?x?xf64, #[[$strided2D]]>
 //       CHECK:         linalg.copy(%[[vC_f64]], %[[partialC_f64]]) : memref<?x?xf64, #[[$strided2D]]>, memref<?x?xf64, #[[$strided2D]]>
 //
 //       CHECK:         linalg.matmul ins(%[[partialA_f64]], %[[partialB_f64]]{{.*}} outs(%[[partialC_f64]]
 //
 //       CHECK:         linalg.copy(%[[partialC_f64]], %[[vC_f64]]) :
 //       CHECK:           memref<?x?xf64, #[[$strided2D]]>,
 //       CHECK:           memref<?x?xf64, #[[$strided2D]]>
 //
-//       CHECK:         dealloc %[[tmpA_f64]] : memref<64xi8>
-//       CHECK:         dealloc %[[tmpB_f64]] : memref<96xi8>
-//       CHECK:         dealloc %[[tmpC_f64]] : memref<48xi8>
+//       CHECK:         memref.dealloc %[[tmpA_f64]] : memref<64xi8>
+//       CHECK:         memref.dealloc %[[tmpB_f64]] : memref<96xi8>
+//       CHECK:         memref.dealloc %[[tmpC_f64]] : memref<48xi8>

mlir/test/Dialect/Linalg/promotion_options.mlir

 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9_]+]]: memref<?x?xf32>
 //  CHECK-DAG: %[[C42:.+]] = constant 4.200000e+01 : f32
 //      CHECK: scf.for
 //      CHECK:   scf.for
 //      CHECK:     scf.for
 //      CHECK:       %[[T7:.+]] = subview %[[ARG0]]
 //      CHECK:       %[[T12:.+]] = subview %[[ARG1]]
 //      CHECK:       %[[T17:.+]] = subview %[[ARG2]]
-//      CHECK:       %[[T18:.+]] = alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 3>
+//      CHECK:       %[[T18:.+]] = memref.alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 3>
 //      CHECK:       %[[T19:.+]] = subview %[[T18]]
-//      CHECK:       %[[T20:.+]] = alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 3>
+//      CHECK:       %[[T20:.+]] = memref.alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 3>
 //      CHECK:       %[[T21:.+]] = subview %[[T20]]
 //      CHECK:       linalg.fill(%[[T19]], %[[C42]])
 //      CHECK:       linalg.copy(%[[T7]], %[[T19]])
 //      CHECK:       linalg.fill(%[[T21]], %[[C42]])
 //      CHECK:       linalg.copy(%[[T17]], %[[T21]])
 //      CHECK:       linalg.matmul ins(%[[T19]], %[[T12]]{{.*}} outs(%[[T21]]
 //  CHECK-NOT:       linalg.fill
 //      CHECK:       linalg.copy(%[[T21]], %[[T17]])
-//      CHECK:       dealloc %[[T18]]
-//      CHECK:       dealloc %[[T20]]
+//      CHECK:       memref.dealloc %[[T18]]
+//      CHECK:       memref.dealloc %[[T20]]

mlir/test/Dialect/Linalg/roundtrip.mlir

 // CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //  CHECK-NEXT:  linalg.range %{{.*}} : %{{.*}} : %{{.*}} : !linalg.range
 
 // -----
 
 func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) {
   %c0 = constant 0 : index
   %0 = muli %arg0, %arg0 : index
-  %1 = alloc (%0) : memref<?xi8>
+  %1 = memref.alloc (%0) : memref<?xi8>
   %2 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
-  %3 = view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xf32>
-  %4 = view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xvector<4x4xf32>>
-  dealloc %1 : memref<?xi8>
+  %3 = memref.view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xf32>
+  %4 = memref.view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xvector<4x4xf32>>
+  memref.dealloc %1 : memref<?xi8>
   return
 }
 // CHECK-LABEL: func @views
 //  CHECK:  muli %{{.*}}, %{{.*}} : index
-//  CHECK-NEXT:  alloc(%{{.*}}) : memref<?xi8>
+//  CHECK-NEXT:  memref.alloc(%{{.*}}) : memref<?xi8>
 //  CHECK-NEXT:  range
-//  CHECK-NEXT:  std.view %{{.*}}[%{{.*}}][%{{.*}}] :
+//  CHECK-NEXT:  memref.view %{{.*}}[%{{.*}}][%{{.*}}] :
 //  CHECK-SAME:     memref<?xi8> to memref<?x?xf32>
-//  CHECK-NEXT:  view %{{.*}}[%{{.*}}][%{{.*}}] :
+//  CHECK-NEXT:  memref.view %{{.*}}[%{{.*}}][%{{.*}}] :
 //  CHECK-SAME:     memref<?xi8> to memref<?x?xvector<4x4xf32>>
-//  CHECK-NEXT:  dealloc %{{.*}} : memref<?xi8>
+//  CHECK-NEXT:  memref.dealloc %{{.*}} : memref<?xi8>
 
 // -----
 
 // CHECK-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECK-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 
 func @ops(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>,
           %arg1: memref<?xf32, offset: ?, strides: [1]>,

 //       CHECK:   linalg.fill(%{{.*}}, %{{.*}}) : memref<?xf32, #[[$strided1D]]>, f32
 
 // -----
 
 // CHECK-DAG: #[[$strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
 // CHECK-DAG: #[[$strided3DT:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)>
 
 func @transpose(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  %0 = transpose %arg0 (i, j, k) -> (k, j, i) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)>>
+  %0 = memref.transpose %arg0 (i, j, k) -> (k, j, i) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)>>
   return
 }
 // CHECK-LABEL: func @transpose
 //       CHECK:   transpose %{{.*}} ([[i:.*]], [[j:.*]], [[k:.*]]) -> ([[k]], [[j]], [[i]]) :
 //  CHECK-SAME:      memref<?x?x?xf32, #[[$strided3D]]> to memref<?x?x?xf32, #[[$strided3DT]]>
 
 // -----
 

mlir/test/Dialect/Linalg/sparse_1d.mlir

 // CHECK-SAME:                %[[VAL_0:.*]]: tensor<32xf32>,
 // CHECK-SAME:                %[[VAL_1:.*]]: f32,
 // CHECK-SAME:                %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_8:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_8:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_7]], %[[VAL_8]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_10:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<32xf32>
 // CHECK:             %[[VAL_11:.*]] = addf %[[VAL_10]], %[[VAL_1]] : f32
 // CHECK:             store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>
 // CHECK:           }
 // CHECK:           %[[VAL_12:.*]] = tensor_load %[[VAL_8]] : memref<32xf32>
 // CHECK:           return %[[VAL_12]] : tensor<32xf32>

 // CHECK-SAME:                %[[VAL_0:.*]]: tensor<32xf32>,
 // CHECK-SAME:                %[[VAL_1:.*]]: f32,
 // CHECK-SAME:                %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_8:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_8:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_7]], %[[VAL_8]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_10:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<32xf32>
 // CHECK:             %[[VAL_11:.*]] = mulf %[[VAL_10]], %[[VAL_1]] : f32
 // CHECK:             store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32>
 // CHECK:           }
 // CHECK:           %[[VAL_12:.*]] = tensor_load %[[VAL_8]] : memref<32xf32>
 // CHECK:           return %[[VAL_12]] : tensor<32xf32>

 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant true
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_12:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_17:.*]] = cmpi ult, %[[VAL_15]], %[[VAL_13]] : index
 // CHECK:             scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_18:.*]]: index, %[[VAL_19:.*]]: index):

 // CHECK-SAME:                         %[[VAL_0:.*]]: tensor<32xf32>,
 // CHECK-SAME:                         %[[VAL_1:.*]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_2:.*]] = constant 0 : index
 // CHECK:           %[[VAL_3:.*]] = constant 1 : index
 // CHECK:           %[[VAL_4:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_2]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_2]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
-// CHECK:           %[[VAL_8:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_8:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_7]], %[[VAL_8]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_9:.*]] = load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] {
 // CHECK:             %[[VAL_12:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32>
 // CHECK:             %[[VAL_15:.*]] = addf %[[VAL_13]], %[[VAL_14]] : f32

 // CHECK-SAME:                %[[VAL_1:.*]]: f32,
 // CHECK-SAME:                %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_9:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_9:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_8]], %[[VAL_9]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_10:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_12]]] : memref<?xf32>
 // CHECK:             %[[VAL_15:.*]] = mulf %[[VAL_14]], %[[VAL_1]] : f32
 // CHECK:             store %[[VAL_15]], %[[VAL_9]]{{\[}}%[[VAL_13]]] : memref<32xf32>

 // CHECK-SAME:                 %[[VAL_1:.*1]]: tensor<32xf32>,
 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_9:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_9:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_8]], %[[VAL_9]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_11:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:             %[[VAL_12:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:             %[[VAL_13:.*]] = addf %[[VAL_11]], %[[VAL_12]] : f32
 // CHECK:             store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:           }
 // CHECK:           %[[VAL_14:.*]] = tensor_load %[[VAL_9]] : memref<32xf32>

 // CHECK-SAME:                 %[[VAL_1:.*1]]: tensor<32xf32>,
 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_9:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_9:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_8]], %[[VAL_9]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_11:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:             %[[VAL_12:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:             %[[VAL_13:.*]] = mulf %[[VAL_11]], %[[VAL_12]] : f32
 // CHECK:             store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32>
 // CHECK:           }
 // CHECK:           %[[VAL_14:.*]] = tensor_load %[[VAL_9]] : memref<32xf32>

 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant true
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_18:.*]] = cmpi ult, %[[VAL_16]], %[[VAL_14]] : index
 // CHECK:             scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index):

 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = tensor_to_memref %[[VAL_0]] : memref<32xf32>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_10:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_10:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_11:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<32xf32>
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xf32>
 // CHECK:             %[[VAL_17:.*]] = mulf %[[VAL_15]], %[[VAL_16]] : f32

 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant true
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_18:.*]] = cmpi ult, %[[VAL_16]], %[[VAL_14]] : index
 // CHECK:             scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index):

 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_10:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_10:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_11:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xf32>
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<32xf32>
 // CHECK:             %[[VAL_17:.*]] = mulf %[[VAL_15]], %[[VAL_16]] : f32

 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
 // CHECK:             %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index

 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32xf32>, memref<32xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
 // CHECK:             %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index

 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_3]] : memref<16xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<16xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<16xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<16xf32>, memref<16xf32>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]]:3 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_4]]) : (index, index, index) -> (index, index, index) {
 // CHECK:             %[[VAL_22:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_15]] : index
 // CHECK:             %[[VAL_23:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_17]] : index

 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_3]] : memref<16xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<16xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<16xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<16xf32>, memref<16xf32>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]]:3 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_4]]) : (index, index, index) -> (index, index, index) {
 // CHECK:             %[[VAL_22:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_15]] : index
 // CHECK:             %[[VAL_23:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_17]] : index

 // CHECK-LABEL:   func @sum_reduction(
 // CHECK-SAME:                        %[[VAL_0:.*]]: tensor<?xf32>,
 // CHECK-SAME:                        %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> {
 // CHECK:           %[[VAL_2:.*]] = constant 0 : index
 // CHECK:           %[[VAL_3:.*]] = constant 1 : index
 // CHECK:           %[[VAL_4:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_2]] : tensor<?xf32> to memref<?xindex>
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?xf32> to memref<?xf32>
 // CHECK:           %[[VAL_6:.*]] = tensor_to_memref %[[VAL_1]] : memref<f32>
-// CHECK:           %[[VAL_7:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_7:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_6]], %[[VAL_7]]) : memref<f32>, memref<f32>
 // CHECK:           %[[VAL_8:.*]] = load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = load %[[VAL_7]][] : memref<f32>
 // CHECK:           %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (f32) {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32>
 // CHECK:             %[[VAL_15:.*]] = addf %[[VAL_13]], %[[VAL_14]] : f32
 // CHECK:             scf.yield %[[VAL_15]] : f32

 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<f32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<f32>, memref<f32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]]:3 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_3]]) : (index, index, index) -> (index, index, index) {
 // CHECK:             %[[VAL_21:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index
 // CHECK:             %[[VAL_22:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index

 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<f32>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_2]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_2]], %[[VAL_4]] : tensor<16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_values %[[VAL_2]] : tensor<16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_3]] : memref<f32>
-// CHECK:           %[[VAL_14:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_14:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<f32>, memref<f32>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_9]][] : memref<f32>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]]:3 = scf.while (%[[VAL_21:.*]] = %[[VAL_16]], %[[VAL_22:.*]] = %[[VAL_18]], %[[VAL_23:.*]] = %[[VAL_4]]) : (index, index, index) -> (index, index, index) {
 // CHECK:             %[[VAL_24:.*]] = cmpi ult, %[[VAL_21]], %[[VAL_17]] : index

mlir/test/Dialect/Linalg/sparse_2d.mlir

 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 16 : index
 // CHECK:           %[[VAL_5:.*]] = constant 0 : index
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_0]] : memref<32x16xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_10:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_10:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
 // CHECK:             scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_13:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:               %[[VAL_14:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:               %[[VAL_15:.*]] = addf %[[VAL_13]], %[[VAL_14]] : f32
 // CHECK:               store %[[VAL_15]], %[[VAL_10]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:             }

 // CHECK-SAME:                 %[[VAL_2:.*2]]: tensor<32x16xf32>) -> tensor<32x16xf32> {
 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 16 : index
 // CHECK:           %[[VAL_5:.*]] = constant 0 : index
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_0]] : memref<32x16xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_10:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_10:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           scf.for %[[VAL_11:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
 // CHECK:             scf.for %[[VAL_12:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_13:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:               %[[VAL_14:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:               %[[VAL_15:.*]] = mulf %[[VAL_13]], %[[VAL_14]] : f32
 // CHECK:               store %[[VAL_15]], %[[VAL_10]]{{\[}}%[[VAL_11]], %[[VAL_12]]] : memref<32x16xf32>
 // CHECK:             }

 // CHECK:           %[[VAL_5:.*]] = constant 0 : index
 // CHECK:           %[[VAL_6:.*]] = constant true
 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           scf.for %[[VAL_14:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_7]] {
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK:             %[[VAL_16:.*]] = addi %[[VAL_14]], %[[VAL_7]] : index
 // CHECK:             %[[VAL_17:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
 // CHECK:             %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_15]], %[[VAL_20:.*]] = %[[VAL_5]]) : (index, index) -> (index, index) {
 // CHECK:               %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_17]] : index
 // CHECK:               scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index

 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK:             %[[VAL_14:.*]] = addi %[[VAL_12]], %[[VAL_5]] : index
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] {
 // CHECK:               %[[VAL_17:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex>
 // CHECK:               %[[VAL_18:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xf32>

 // CHECK:           %[[VAL_5:.*]] = constant true
 // CHECK:           %[[VAL_6:.*]] = constant 0 : index
 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]]:2 = scf.while (%[[VAL_17:.*]] = %[[VAL_14]], %[[VAL_18:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_19:.*]] = cmpi ult, %[[VAL_17]], %[[VAL_15]] : index
 // CHECK:             scf.condition(%[[VAL_19]]) %[[VAL_17]], %[[VAL_18]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_20:.*]]: index, %[[VAL_21:.*]]: index):

 // CHECK:           %[[VAL_3:.*]] = constant 16 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_12:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_14:.*]] = %[[VAL_12]] to %[[VAL_13]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_16:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:               %[[VAL_17:.*]] = muli %[[VAL_14]], %[[VAL_3]] : index
 // CHECK:               %[[VAL_18:.*]] = addi %[[VAL_17]], %[[VAL_16]] : index

 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_14:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_15:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_15:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_14]], %[[VAL_15]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_7]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_16]], %[[VAL_20:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_17]] : index
 // CHECK:             scf.condition(%[[VAL_21]]) %[[VAL_19]], %[[VAL_20]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_22:.*]]: index, %[[VAL_23:.*]]: index):

 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             %[[VAL_17:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             %[[VAL_18:.*]] = addi %[[VAL_15]], %[[VAL_4]] : index
 // CHECK:             %[[VAL_19:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex>

 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_24:.*]] = cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
 // CHECK:             %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_20]] : index

 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_24:.*]] = cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
 // CHECK:             %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_20]] : index

 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_24:.*]] = cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
 // CHECK:             %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_20]] : index

 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<32x16xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<32x16xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc() : memref<32x16xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc() : memref<32x16xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16xf32>, memref<32x16xf32>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_21:.*]]:2 = scf.while (%[[VAL_22:.*]] = %[[VAL_17]], %[[VAL_23:.*]] = %[[VAL_19]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_24:.*]] = cmpi ult, %[[VAL_22]], %[[VAL_18]] : index
 // CHECK:             %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_20]] : index

 // CHECK:           %[[VAL_3:.*]] = constant 16 : index
 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<16x32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<16x32xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<16x32xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<32xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<16xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<16xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<16xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<16xf32>, memref<16xf32>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK:             %[[VAL_14:.*]] = addi %[[VAL_12]], %[[VAL_5]] : index
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_11]]{{\[}}%[[VAL_12]]] : memref<16xf32>
 // CHECK:             %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_5]] iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (f32) {
 // CHECK:               %[[VAL_20:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex>

 // CHECK-SAME:                        %[[VAL_0:.*]]: tensor<10x20xf32>,
 // CHECK-SAME:                        %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> {
 // CHECK:           %[[VAL_2:.*]] = constant 10 : index
 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<10x20xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<10x20xf32> to memref<?xf32>
 // CHECK:           %[[VAL_7:.*]] = tensor_to_memref %[[VAL_1]] : memref<f32>
-// CHECK:           %[[VAL_8:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_8:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_7]], %[[VAL_8]]) : memref<f32>, memref<f32>
 // CHECK:           scf.for %[[VAL_9:.*]] = %[[VAL_3]] to %[[VAL_2]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_10:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_9]]] : memref<?xindex>
 // CHECK:             %[[VAL_11:.*]] = addi %[[VAL_9]], %[[VAL_4]] : index
 // CHECK:             %[[VAL_12:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex>
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_8]][] : memref<f32>
 // CHECK:             %[[VAL_14:.*]] = scf.for %[[VAL_15:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_4]] iter_args(%[[VAL_16:.*]] = %[[VAL_13]]) -> (f32) {
 // CHECK:               %[[VAL_17:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xf32>

 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?x?xf64> to memref<?xf64>
 // CHECK:           %[[VAL_8:.*]] = dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf64>
 // CHECK:           %[[VAL_9:.*]] = dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf64>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<?x?xf64>
-// CHECK:           %[[VAL_11:.*]] = alloc(%[[VAL_8]], %[[VAL_9]]) : memref<?x?xf64>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc(%[[VAL_8]], %[[VAL_9]]) : memref<?x?xf64>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<?x?xf64>, memref<?x?xf64>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_3]] to %[[VAL_8]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_13:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK:             %[[VAL_14:.*]] = addi %[[VAL_12]], %[[VAL_4]] : index
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_16:.*]] = %[[VAL_13]] to %[[VAL_15]] step %[[VAL_4]] {
 // CHECK:               %[[VAL_17:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_16]]] : memref<?xindex>
 // CHECK:               %[[VAL_18:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xf64>

 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<?x?xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?x?xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_1]] : memref<?x?xf32>
 // CHECK:           %[[VAL_12:.*]] = dim %[[VAL_2]], %[[VAL_4]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_2]] : memref<?x?xf32>
 // CHECK:           %[[VAL_14:.*]] = dim %[[VAL_3]], %[[VAL_4]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_15:.*]] = dim %[[VAL_3]], %[[VAL_5]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_16:.*]] = tensor_to_memref %[[VAL_3]] : memref<?x?xf32>
-// CHECK:           %[[VAL_17:.*]] = alloc(%[[VAL_14]], %[[VAL_15]]) : memref<?x?xf32>
+// CHECK:           %[[VAL_17:.*]] = memref.alloc(%[[VAL_14]], %[[VAL_15]]) : memref<?x?xf32>
 // CHECK:           linalg.copy(%[[VAL_16]], %[[VAL_17]]) : memref<?x?xf32>, memref<?x?xf32>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_20:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_21:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_22:.*]] = %[[VAL_4]] to %[[VAL_12]] step %[[VAL_5]] {
 // CHECK:               %[[VAL_23:.*]] = load %[[VAL_11]]{{\[}}%[[VAL_21]], %[[VAL_22]]] : memref<?x?xf32>
 // CHECK:               %[[VAL_24:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_20]]] : memref<?xindex>

 // CHECK:           %[[VAL_16:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<?x?xf32> to memref<?xf32>
 // CHECK:           %[[VAL_17:.*]] = linalg.sparse_pointers %[[VAL_2]], %[[VAL_8]] : tensor<?x?xf32> to memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = linalg.sparse_indices %[[VAL_2]], %[[VAL_8]] : tensor<?x?xf32> to memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = linalg.sparse_values %[[VAL_2]] : tensor<?x?xf32> to memref<?xf32>
 // CHECK:           %[[VAL_20:.*]] = tensor_to_memref %[[VAL_3]] : memref<?xf32>
 // CHECK:           %[[VAL_21:.*]] = tensor_to_memref %[[VAL_4]] : memref<f32>
 // CHECK:           %[[VAL_22:.*]] = dim %[[VAL_5]], %[[VAL_6]] : tensor<?xf32>
 // CHECK:           %[[VAL_23:.*]] = tensor_to_memref %[[VAL_5]] : memref<?xf32>
-// CHECK:           %[[VAL_24:.*]] = alloc(%[[VAL_22]]) : memref<?xf32>
+// CHECK:           %[[VAL_24:.*]] = memref.alloc(%[[VAL_22]]) : memref<?xf32>
 // CHECK:           linalg.copy(%[[VAL_23]], %[[VAL_24]]) : memref<?xf32>, memref<?xf32>
 // CHECK:           %[[VAL_25:.*]] = load %[[VAL_21]][] : memref<f32>
 // CHECK:           %[[VAL_26:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           %[[VAL_27:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex>
 // CHECK:           %[[VAL_28:.*]]:2 = scf.while (%[[VAL_29:.*]] = %[[VAL_26]], %[[VAL_30:.*]] = %[[VAL_6]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_31:.*]] = cmpi ult, %[[VAL_29]], %[[VAL_27]] : index
 // CHECK:             scf.condition(%[[VAL_31]]) %[[VAL_29]], %[[VAL_30]] : index, index
 // CHECK:           } do {

mlir/test/Dialect/Linalg/sparse_3d.mlir

 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 16 : index
 // CHECK:           %[[VAL_5:.*]] = constant 8 : index
 // CHECK:           %[[VAL_6:.*]] = constant 0 : index
 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_0]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] {
 // CHECK:             scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
 // CHECK:               scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
 // CHECK:                 %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>
 // CHECK:                 %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>
 // CHECK:                 %[[VAL_17:.*]] = addf %[[VAL_15]], %[[VAL_16]] : f32
 // CHECK:                 store %[[VAL_17]], %[[VAL_11]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>

 // CHECK:           %[[VAL_3:.*]] = constant 32 : index
 // CHECK:           %[[VAL_4:.*]] = constant 16 : index
 // CHECK:           %[[VAL_5:.*]] = constant 8 : index
 // CHECK:           %[[VAL_6:.*]] = constant 0 : index
 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_0]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_11:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_11:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] {
 // CHECK:             scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
 // CHECK:               scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
 // CHECK:                 %[[VAL_15:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>
 // CHECK:                 %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>
 // CHECK:                 %[[VAL_17:.*]] = mulf %[[VAL_15]], %[[VAL_16]] : f32
 // CHECK:                 store %[[VAL_17]], %[[VAL_11]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_14]]] : memref<32x16x8xf32>

 // CHECK:           %[[VAL_7:.*]] = constant 0 : index
 // CHECK:           %[[VAL_8:.*]] = constant true
 // CHECK:           %[[VAL_9:.*]] = constant 1 : index
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_14:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_15:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_15:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_14]], %[[VAL_15]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_9]] {
 // CHECK:             scf.for %[[VAL_17:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_9]] {
 // CHECK:               %[[VAL_18:.*]] = muli %[[VAL_16]], %[[VAL_5]] : index
 // CHECK:               %[[VAL_19:.*]] = addi %[[VAL_18]], %[[VAL_17]] : index
 // CHECK:               %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xindex>
 // CHECK:               %[[VAL_21:.*]] = addi %[[VAL_19]], %[[VAL_9]] : index
 // CHECK:               %[[VAL_22:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_21]]] : memref<?xindex>

 // CHECK:           %[[VAL_5:.*]] = constant 16 : index
 // CHECK:           %[[VAL_6:.*]] = constant 0 : index
 // CHECK:           %[[VAL_7:.*]] = constant 1 : index
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] {
 // CHECK:             scf.for %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] {
 // CHECK:               %[[VAL_16:.*]] = muli %[[VAL_14]], %[[VAL_5]] : index
 // CHECK:               %[[VAL_17:.*]] = addi %[[VAL_16]], %[[VAL_15]] : index
 // CHECK:               %[[VAL_18:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:               %[[VAL_19:.*]] = addi %[[VAL_17]], %[[VAL_7]] : index
 // CHECK:               %[[VAL_20:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex>

 // CHECK:           %[[VAL_6:.*]] = constant true
 // CHECK:           %[[VAL_7:.*]] = constant 0 : index
 // CHECK:           %[[VAL_8:.*]] = constant 1 : index
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_14:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_15:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_8]] {
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             %[[VAL_17:.*]] = addi %[[VAL_15]], %[[VAL_8]] : index
 // CHECK:             %[[VAL_18:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:             %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
 // CHECK:               %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_18]] : index
 // CHECK:               scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index

 // CHECK:           %[[VAL_4:.*]] = constant 8 : index
 // CHECK:           %[[VAL_5:.*]] = constant 0 : index
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_15:.*]] = addi %[[VAL_13]], %[[VAL_6]] : index
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_18:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:               scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {

 // CHECK:           %[[VAL_9:.*]] = constant 1 : index
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_16:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_17:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_17:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_16]], %[[VAL_17]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_18:.*]] = %[[VAL_8]] to %[[VAL_4]] step %[[VAL_9]] {
 // CHECK:             %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_18]]] : memref<?xindex>
 // CHECK:             %[[VAL_20:.*]] = addi %[[VAL_18]], %[[VAL_9]] : index
 // CHECK:             %[[VAL_21:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xindex>
 // CHECK:             %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
 // CHECK:               %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_21]] : index
 // CHECK:               scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index

 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_14:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           scf.for %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             %[[VAL_17:.*]] = addi %[[VAL_15]], %[[VAL_6]] : index
 // CHECK:             %[[VAL_18:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_20:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex>
 // CHECK:               %[[VAL_21:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xindex>

 // CHECK:           %[[VAL_6:.*]] = constant true
 // CHECK:           %[[VAL_7:.*]] = constant 0 : index
 // CHECK:           %[[VAL_8:.*]] = constant 1 : index
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_14:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_15]], %[[VAL_19:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_16]] : index
 // CHECK:             scf.condition(%[[VAL_20]]) %[[VAL_18]], %[[VAL_19]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_21:.*]]: index, %[[VAL_22:.*]]: index):

 // CHECK:           %[[VAL_4:.*]] = constant 8 : index
 // CHECK:           %[[VAL_5:.*]] = constant 0 : index
 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_13:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_6]] {
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_18:.*]] = muli %[[VAL_15]], %[[VAL_3]] : index
 // CHECK:               %[[VAL_19:.*]] = addi %[[VAL_18]], %[[VAL_17]] : index

 // CHECK:           %[[VAL_9:.*]] = constant 1 : index
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_16:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_17:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_17:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_16]], %[[VAL_17]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex>
 // CHECK:           %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_18]], %[[VAL_22:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_23:.*]] = cmpi ult, %[[VAL_21]], %[[VAL_19]] : index
 // CHECK:             scf.condition(%[[VAL_23]]) %[[VAL_21]], %[[VAL_22]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index):

 // CHECK:           %[[VAL_6:.*]] = constant 1 : index
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_14:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_6]] {
 // CHECK:             %[[VAL_18:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_20:.*]] = muli %[[VAL_17]], %[[VAL_4]] : index
 // CHECK:               %[[VAL_21:.*]] = addi %[[VAL_20]], %[[VAL_19]] : index

 // CHECK:           %[[VAL_8:.*]] = constant 1 : index
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_14:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex>
 // CHECK:           %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_17]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_18]] : index
 // CHECK:             scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index):

 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_17:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex>
 // CHECK:             %[[VAL_18:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex>
 // CHECK:             %[[VAL_19:.*]] = addi %[[VAL_16]], %[[VAL_5]] : index
 // CHECK:             %[[VAL_20:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex>

 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_13:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_17:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_18:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_19:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_19:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_18]], %[[VAL_19]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_20:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex>
 // CHECK:           %[[VAL_21:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex>
 // CHECK:           %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_20]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) {
 // CHECK:             %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_21]] : index
 // CHECK:             scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index
 // CHECK:           } do {
 // CHECK:           ^bb0(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index):

 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_10:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_11:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32> to memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<32x16x8xf32> to memref<?xf32>
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_1]] : memref<32x16x8xf32>
 // CHECK:           %[[VAL_14:.*]] = tensor_to_memref %[[VAL_2]] : memref<32x16x8xf32>
-// CHECK:           %[[VAL_15:.*]] = alloc() : memref<32x16x8xf32>
+// CHECK:           %[[VAL_15:.*]] = memref.alloc() : memref<32x16x8xf32>
 // CHECK:           linalg.copy(%[[VAL_14]], %[[VAL_15]]) : memref<32x16x8xf32>, memref<32x16x8xf32>
 // CHECK:           %[[VAL_16:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_19:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex>
 // CHECK:             %[[VAL_20:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex>
 // CHECK:             %[[VAL_21:.*]] = addi %[[VAL_18]], %[[VAL_5]] : index
 // CHECK:             %[[VAL_22:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_21]]] : memref<?xindex>

 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<?x?x?xf32> to memref<?xindex>
 // CHECK:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<?x?x?xf32> to memref<?xf32>
 // CHECK:           %[[VAL_10:.*]] = dim %[[VAL_2]], %[[VAL_5]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<?x?xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_3]] : memref<?x?xf32>
 // CHECK:           %[[VAL_13:.*]] = dim %[[VAL_0]], %[[VAL_5]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_14:.*]] = dim %[[VAL_0]], %[[VAL_6]] : tensor<?x?xf32>
 // CHECK:           %[[VAL_15:.*]] = tensor_to_memref %[[VAL_0]] : memref<?x?xf32>
-// CHECK:           %[[VAL_16:.*]] = alloc(%[[VAL_13]], %[[VAL_14]]) : memref<?x?xf32>
+// CHECK:           %[[VAL_16:.*]] = memref.alloc(%[[VAL_13]], %[[VAL_14]]) : memref<?x?xf32>
 // CHECK:           linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<?x?xf32>, memref<?x?xf32>
 // CHECK:           scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_13]] step %[[VAL_6]] {
 // CHECK:             scf.for %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_10]] step %[[VAL_6]] {
 // CHECK:               %[[VAL_19:.*]] = muli %[[VAL_10]], %[[VAL_17]] : index
 // CHECK:               %[[VAL_20:.*]] = addi %[[VAL_19]], %[[VAL_18]] : index
 // CHECK:               %[[VAL_21:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<?xindex>
 // CHECK:               %[[VAL_22:.*]] = addi %[[VAL_20]], %[[VAL_6]] : index
 // CHECK:               %[[VAL_23:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_22]]] : memref<?xindex>

 // CHECK:           %[[VAL_2:.*]] = constant 2 : index
 // CHECK:           %[[VAL_3:.*]] = constant 0 : index
 // CHECK:           %[[VAL_4:.*]] = constant 1 : index
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_3]] : tensor<10x20x30xf32> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<10x20x30xf32> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_2]] : tensor<10x20x30xf32> to memref<?xindex>
 // CHECK:           %[[VAL_8:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<10x20x30xf32> to memref<?xf32>
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<f32>
-// CHECK:           %[[VAL_10:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_10:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<f32>, memref<f32>
 // CHECK:           %[[VAL_11:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex>
 // CHECK:           %[[VAL_12:.*]] = load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex>
 // CHECK:           scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK:             %[[VAL_15:.*]] = addi %[[VAL_13]], %[[VAL_4]] : index
 // CHECK:             %[[VAL_16:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK:             scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_4]] {

 // CHECK:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK:           %[[VAL_6:.*]] = dim %[[VAL_0]], %[[VAL_5]] : tensor<?x?x?xf32>
 // CHECK:           %[[VAL_7:.*]] = dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?x?xf32>
 // CHECK:           %[[VAL_8:.*]] = tensor_to_memref %[[VAL_0]] : memref<?x?x?xf32>
 // CHECK:           %[[VAL_9:.*]] = dim %[[VAL_1]], %[[VAL_4]] : tensor<?xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<?xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<f32>
-// CHECK:           %[[VAL_12:.*]] = alloc() : memref<f32>
+// CHECK:           %[[VAL_12:.*]] = memref.alloc() : memref<f32>
 // CHECK:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<f32>, memref<f32>
 // CHECK:           scf.for %[[VAL_13:.*]] = %[[VAL_4]] to %[[VAL_9]] step %[[VAL_5]] {
 // CHECK:             %[[VAL_14:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_13]]] : memref<?xf32>
 // CHECK:             scf.for %[[VAL_15:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_5]] {
 // CHECK:               %[[VAL_16:.*]] = load %[[VAL_12]][] : memref<f32>
 // CHECK:               %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_4]] to %[[VAL_7]] step %[[VAL_5]] iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (f32) {
 // CHECK:                 %[[VAL_20:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_13]], %[[VAL_15]], %[[VAL_18]]] : memref<?x?x?xf32>
 // CHECK:                 %[[VAL_21:.*]] = mulf %[[VAL_20]], %[[VAL_14]] : f32

 // CHECK:           %[[VAL_5:.*]] = constant 20 : index
 // CHECK:           %[[VAL_6:.*]] = constant 30 : index
 // CHECK:           %[[VAL_7:.*]] = constant 0 : index
 // CHECK:           %[[VAL_8:.*]] = constant 1 : index
 // CHECK:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_0]] : memref<10xf32>
 // CHECK:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<20xf32>
 // CHECK:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<30xf32>
 // CHECK:           %[[VAL_12:.*]] = tensor_to_memref %[[VAL_3]] : memref<10x20x30xf32>
-// CHECK:           %[[VAL_13:.*]] = alloc() : memref<10x20x30xf32>
+// CHECK:           %[[VAL_13:.*]] = memref.alloc() : memref<10x20x30xf32>
 // CHECK:           linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<10x20x30xf32>, memref<10x20x30xf32>
 // CHECK:           scf.for %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] {
 // CHECK:             %[[VAL_15:.*]] = load %[[VAL_9]]{{\[}}%[[VAL_14]]] : memref<10xf32>
 // CHECK:             scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] {
 // CHECK:               %[[VAL_17:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_16]]] : memref<20xf32>
 // CHECK:               scf.for %[[VAL_18:.*]] = %[[VAL_7]] to %[[VAL_6]] step %[[VAL_8]] {
 // CHECK:                 %[[VAL_19:.*]] = mulf %[[VAL_15]], %[[VAL_17]] : f32
 // CHECK:                 %[[VAL_20:.*]] = load %[[VAL_11]]{{\[}}%[[VAL_18]]] : memref<30xf32>

mlir/test/Dialect/Linalg/sparse_lower.mlir

 // CHECK-HIR:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK-HIR:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK-HIR:           %[[VAL_6:.*]] = linalg.sparse_tensor %[[VAL_0]] : !llvm.ptr<i8> to tensor<64x64xf64>
 // CHECK-HIR:           %[[VAL_7:.*]] = linalg.sparse_pointers %[[VAL_6]], %[[VAL_5]] : tensor<64x64xf64> to memref<?xindex>
 // CHECK-HIR:           %[[VAL_8:.*]] = linalg.sparse_indices %[[VAL_6]], %[[VAL_5]] : tensor<64x64xf64> to memref<?xindex>
 // CHECK-HIR:           %[[VAL_9:.*]] = linalg.sparse_values %[[VAL_6]] : tensor<64x64xf64> to memref<?xf64>
 // CHECK-HIR:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_1]] : memref<64xf64>
 // CHECK-HIR:           %[[VAL_11:.*]] = tensor_to_memref %[[VAL_2]] : memref<64xf64>
-// CHECK-HIR:           %[[VAL_12:.*]] = alloc() : memref<64xf64>
+// CHECK-HIR:           %[[VAL_12:.*]] = memref.alloc() : memref<64xf64>
 // CHECK-HIR:           linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<64xf64>, memref<64xf64>
 // CHECK-HIR:           scf.for %[[VAL_13:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-HIR:             %[[VAL_14:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex>
 // CHECK-HIR:             %[[VAL_15:.*]] = addi %[[VAL_13]], %[[VAL_5]] : index
 // CHECK-HIR:             %[[VAL_16:.*]] = load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex>
 // CHECK-HIR:             %[[VAL_17:.*]] = load %[[VAL_12]]{{\[}}%[[VAL_13]]] : memref<64xf64>
 // CHECK-HIR:             %[[VAL_18:.*]] = scf.for %[[VAL_19:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_5]] iter_args(%[[VAL_20:.*]] = %[[VAL_17]]) -> (f64) {
 // CHECK-HIR:               %[[VAL_21:.*]] = load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex>

 // CHECK-MIR:           %[[VAL_3:.*]] = constant 64 : index
 // CHECK-MIR:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK-MIR:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK-MIR:           %[[VAL_6:.*]] = call @sparsePointers64(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr<i8>, index) -> memref<?xindex>
 // CHECK-MIR:           %[[VAL_7:.*]] = call @sparseIndices64(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr<i8>, index) -> memref<?xindex>
 // CHECK-MIR:           %[[VAL_8:.*]] = call @sparseValuesF64(%[[VAL_0]]) : (!llvm.ptr<i8>) -> memref<?xf64>
 // CHECK-MIR:           %[[VAL_9:.*]] = tensor_to_memref %[[VAL_1]] : memref<64xf64>
 // CHECK-MIR:           %[[VAL_10:.*]] = tensor_to_memref %[[VAL_2]] : memref<64xf64>
-// CHECK-MIR:           %[[VAL_11:.*]] = alloc() : memref<64xf64>
+// CHECK-MIR:           %[[VAL_11:.*]] = memref.alloc() : memref<64xf64>
 // CHECK-MIR:           scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-MIR:             %[[VAL_13:.*]] = load %[[VAL_10]]{{\[}}%[[VAL_12]]] : memref<64xf64>
 // CHECK-MIR:             store %[[VAL_13]], %[[VAL_11]]{{\[}}%[[VAL_12]]] : memref<64xf64>
 // CHECK-MIR:           }
 // CHECK-MIR:           scf.for %[[VAL_14:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-MIR:             %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>
 // CHECK-MIR:             %[[VAL_16:.*]] = addi %[[VAL_14]], %[[VAL_5]] : index
 // CHECK-MIR:             %[[VAL_17:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_16]]] : memref<?xindex>

 // CHECK-LIR-SAME:                 %[[VAL_1:.*]]: memref<64xf64>,
 // CHECK-LIR-SAME:                 %[[VAL_2:.*]]: memref<64xf64>) -> memref<64xf64> {
 // CHECK-LIR:           %[[VAL_3:.*]] = constant 64 : index
 // CHECK-LIR:           %[[VAL_4:.*]] = constant 0 : index
 // CHECK-LIR:           %[[VAL_5:.*]] = constant 1 : index
 // CHECK-LIR:           %[[VAL_6:.*]] = call @sparsePointers64(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr<i8>, index) -> memref<?xindex>
 // CHECK-LIR:           %[[VAL_7:.*]] = call @sparseIndices64(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr<i8>, index) -> memref<?xindex>
 // CHECK-LIR:           %[[VAL_8:.*]] = call @sparseValuesF64(%[[VAL_0]]) : (!llvm.ptr<i8>) -> memref<?xf64>
-// CHECK-LIR:           %[[VAL_9:.*]] = alloc() : memref<64xf64>
+// CHECK-LIR:           %[[VAL_9:.*]] = memref.alloc() : memref<64xf64>
 // CHECK-LIR:           scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-LIR:             %[[VAL_11:.*]] = load %[[VAL_2]]{{\[}}%[[VAL_10]]] : memref<64xf64>
 // CHECK-LIR:             store %[[VAL_11]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<64xf64>
 // CHECK-LIR:           }
 // CHECK-LIR:           scf.for %[[VAL_12:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] {
 // CHECK-LIR:             %[[VAL_13:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex>
 // CHECK-LIR:             %[[VAL_14:.*]] = addi %[[VAL_12]], %[[VAL_5]] : index
 // CHECK-LIR:             %[[VAL_15:.*]] = load %[[VAL_6]]{{\[}}%[[VAL_14]]] : memref<?xindex>

mlir/test/Dialect/Linalg/sparse_nd.mlir

 // CHECK:           %[[VAL_12:.*]] = constant 1 : index
 // CHECK:           %[[VAL_13:.*]] = tensor_to_memref %[[VAL_0]] : memref<10x20x30x40x50x60x70x80xf32>
 // CHECK:           %[[VAL_14:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_3]] : tensor<10x20x30x40x50x60x70x80xf32> to memref<?xindex>
 // CHECK:           %[[VAL_15:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_3]] : tensor<10x20x30x40x50x60x70x80xf32> to memref<?xindex>
 // CHECK:           %[[VAL_16:.*]] = linalg.sparse_pointers %[[VAL_1]], %[[VAL_4]] : tensor<10x20x30x40x50x60x70x80xf32> to memref<?xindex>
 // CHECK:           %[[VAL_17:.*]] = linalg.sparse_indices %[[VAL_1]], %[[VAL_4]] : tensor<10x20x30x40x50x60x70x80xf32> to memref<?xindex>
 // CHECK:           %[[VAL_18:.*]] = linalg.sparse_values %[[VAL_1]] : tensor<10x20x30x40x50x60x70x80xf32> to memref<?xf32>
 // CHECK:           %[[VAL_19:.*]] = tensor_to_memref %[[VAL_2]] : memref<10x20x30x40x50x60x70x80xf32>
-// CHECK:           %[[VAL_20:.*]] = alloc() : memref<10x20x30x40x50x60x70x80xf32>
+// CHECK:           %[[VAL_20:.*]] = memref.alloc() : memref<10x20x30x40x50x60x70x80xf32>
 // CHECK:           linalg.copy(%[[VAL_19]], %[[VAL_20]]) : memref<10x20x30x40x50x60x70x80xf32>, memref<10x20x30x40x50x60x70x80xf32>
 // CHECK:           scf.for %[[VAL_21:.*]] = %[[VAL_11]] to %[[VAL_10]] step %[[VAL_12]] {
 // CHECK:             scf.for %[[VAL_22:.*]] = %[[VAL_11]] to %[[VAL_9]] step %[[VAL_12]] {
 // CHECK:               %[[VAL_23:.*]] = muli %[[VAL_21]], %[[VAL_9]] : index
 // CHECK:               %[[VAL_24:.*]] = addi %[[VAL_23]], %[[VAL_22]] : index
 // CHECK:               scf.for %[[VAL_25:.*]] = %[[VAL_11]] to %[[VAL_8]] step %[[VAL_12]] {
 // CHECK:                 %[[VAL_26:.*]] = muli %[[VAL_24]], %[[VAL_8]] : index
 // CHECK:                 %[[VAL_27:.*]] = addi %[[VAL_26]], %[[VAL_25]] : index

 // CHECK:                         %[[VAL_42:.*]] = muli %[[VAL_40]], %[[VAL_6]] : index
 // CHECK:                         %[[VAL_43:.*]] = addi %[[VAL_42]], %[[VAL_41]] : index
 // CHECK:                         scf.for %[[VAL_44:.*]] = %[[VAL_11]] to %[[VAL_5]] step %[[VAL_12]] {
 // CHECK:                           %[[VAL_45:.*]] = muli %[[VAL_43]], %[[VAL_5]] : index
 // CHECK:                           %[[VAL_46:.*]] = addi %[[VAL_45]], %[[VAL_44]] : index
 // CHECK:                           %[[VAL_47:.*]] = load %[[VAL_13]]{{\[}}%[[VAL_44]], %[[VAL_41]], %[[VAL_38]], %[[VAL_37]], %[[VAL_32]], %[[VAL_25]], %[[VAL_22]], %[[VAL_21]]] : memref<10x20x30x40x50x60x70x80xf32>
 // CHECK:                           %[[VAL_48:.*]] = load %[[VAL_18]]{{\[}}%[[VAL_46]]] : memref<?xf32>
 // CHECK:                           %[[VAL_49:.*]] = mulf %[[VAL_47]], %[[VAL_48]] : f32
-// CHECK:                           store %[[VAL_49]], %[[VAL_20]]{{\[}}%[[VAL_44]], %[[VAL_41]], %[[VAL_38]], %[[VAL_37]], %[[VAL_32]], %[[VAL_25]], %[[VAL_22]], %[[VAL_21]]] : memref<10x20x30x40x50x60x70x80xf32>
+// CHECK:                           memref.store %[[VAL_49]], %[[VAL_20]]{{\[}}%[[VAL_44]], %[[VAL_41]], %[[VAL_38]], %[[VAL_37]], %[[VAL_32]], %[[VAL_25]], %[[VAL_22]], %[[VAL_21]]] : memref<10x20x30x40x50x60x70x80xf32>
 // CHECK:                         }
 // CHECK:                       }
 // CHECK:                     }
 // CHECK:                   }
 // CHECK:                 }
 // CHECK:               }
 // CHECK:             }
 // CHECK:           }

mlir/test/Dialect/Linalg/standard.mlir

linalg.dot ins(%arg0, %arg1: memref<?xf32, offset: ?, strides: [1]>,
                                memref<?xf32, offset: ?, strides: [1]>)
              outs(%arg2: memref<f32>)
   return
 }
 // CHECK-LABEL: func @dot(
 //  CHECK-SAME: %[[arg0:[a-zA-z0-9]*]]: memref<?xf32, #[[$map0]]>,
 //  CHECK-SAME: %[[arg1:[a-zA-z0-9]*]]: memref<?xf32, #[[$map0]]>,
 //  CHECK-SAME: %[[arg2:[a-zA-z0-9]*]]: memref<f32>) {
-//       CHECK:   %[[o0:.*]] = memref_cast %[[arg0]] :
+//       CHECK:   %[[o0:.*]] = memref.cast %[[arg0]] :
 //  CHECK-SAME:     memref<?xf32, #[[$map0]]> to memref<?xf32, #[[$map6]]>
-//       CHECK:   %[[o1:.*]] = memref_cast %[[arg1]] :
+//       CHECK:   %[[o1:.*]] = memref.cast %[[arg1]] :
 //  CHECK-SAME:     memref<?xf32, #[[$map0]]> to memref<?xf32, #[[$map6]]>
-//       CHECK:   %[[o2:.*]] = memref_cast %[[arg2]] :
+//       CHECK:   %[[o2:.*]] = memref.cast %[[arg2]] :
 //  CHECK-SAME:     memref<f32> to memref<f32, #[[$map7]]>
 //       CHECK:   call @linalg_dot_viewsxf32_viewsxf32_viewf32(
 //  CHECK-SAME:     %[[o0]], %[[o1]], %[[o2]]) :
 //  CHECK-SAME:   memref<?xf32, #[[$map6]]>, memref<?xf32, #[[$map6]]>, memref<f32, #[[$map7]]>
 
 func @copy(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
   linalg.copy(%arg0, %arg1) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @copy(
 //  CHECK-SAME: %[[arg0:[a-zA-z0-9]*]]: memref<?x?x?xf32, #[[$map1]]>,
 //  CHECK-SAME: %[[arg1:[a-zA-z0-9]*]]: memref<?x?x?xf32, #[[$map1]]>) {
-//       CHECK:   %[[o0:.*]] = memref_cast %[[arg0]] :
+//       CHECK:   %[[o0:.*]] = memref.cast %[[arg0]] :
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$map1]]> to memref<?x?x?xf32, #[[$map8]]>
-//       CHECK:   %[[o1:.*]] = memref_cast %[[arg1]] :
+//       CHECK:   %[[o1:.*]] = memref.cast %[[arg1]] :
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$map1]]> to memref<?x?x?xf32, #[[$map8]]>
 //       CHECK:   call @linalg_copy_viewsxsxsxf32_viewsxsxsxf32(%[[o0]], %[[o1]]) :
 //  CHECK-SAME:   memref<?x?x?xf32, #[[$map8]]>, memref<?x?x?xf32, #[[$map8]]>
 
 func @copy_transpose(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
   linalg.copy(%arg0, %arg1) {inputPermutation = affine_map<(i, j, k) -> (i, k, j)>,
                              outputPermutation = affine_map<(i, j, k) -> (k, j, i)>}
     : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @copy_transpose(
 //  CHECK-SAME: %[[arg0:[a-zA-z0-9]*]]: memref<?x?x?xf32, #[[$map1]]>,
 //  CHECK-SAME: %[[arg1:[a-zA-z0-9]*]]: memref<?x?x?xf32, #[[$map1]]>) {
 //       CHECK:   %[[t0:.*]] = transpose %[[arg0]]
 //  CHECK-SAME:     (d0, d1, d2) -> (d0, d2, d1) : memref<?x?x?xf32, #[[$map1]]>
 //       CHECK:   %[[t1:.*]] = transpose %[[arg1]]
 //  CHECK-SAME:     (d0, d1, d2) -> (d2, d1, d0) : memref<?x?x?xf32, #[[$map1]]>
-//       CHECK:   %[[o0:.*]] = memref_cast %[[t0]] :
+//       CHECK:   %[[o0:.*]] = memref.cast %[[t0]] :
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$map2]]> to memref<?x?x?xf32, #[[$map8]]>
-//       CHECK:   %[[o1:.*]] = memref_cast %[[t1]] :
+//       CHECK:   %[[o1:.*]] = memref.cast %[[t1]] :
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$map4]]> to memref<?x?x?xf32, #[[$map8]]>
 //       CHECK:   call @linalg_copy_viewsxsxsxf32_viewsxsxsxf32(%[[o0]], %[[o1]]) :
 //  CHECK-SAME:   memref<?x?x?xf32, #[[$map8]]>, memref<?x?x?xf32, #[[$map8]]>
 
 #matmul_accesses = [
   affine_map<(m, n, k) -> (m, k)>,
   affine_map<(m, n, k) -> (k, n)>,
   affine_map<(m, n, k) -> (m, n)>

mlir/test/Dialect/Linalg/transform-patterns.mlir

 // CHECK-DAG:     %[[c3000:.*]] = constant 3000 : index
 // CHECK-DAG:     %[[c4000:.*]] = constant 4000 : index
 // CHECK:         scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
 // CHECK:           scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
 // CHECK:             scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
 // CHECK:               %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:               %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:               %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK:               %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK:               %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK:               %[[a0:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK:               %[[v0:.*]] = memref.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK:               %[[l0:.*]] = subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1]
 // CHECK-SAME:            memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
-// CHECK:               %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK:               %[[v1:.*]] = std.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK:               %[[a1:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK:               %[[v1:.*]] = memref.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK:               %[[l1:.*]] = subview %[[v1]][0, 0] [%{{.*}}, %{{.*}}] [1, 1]
 // CHECK-SAME:            memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
-// CHECK:               %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK:               %[[v2:.*]] = std.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK:               %[[a2:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK:               %[[v2:.*]] = memref.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK:               %[[l2:.*]] = subview %[[v2]][0, 0] [%{{.*}}, %{{.*}}] [1, 1]
 // CHECK-SAME:            memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
 // CHECK:               linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK:               linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK:               linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK:               linalg.matmul
 // CHECK-SAME:                 ins(%[[v0]], %[[v1]] : memref<?x?xf32>, memref<?x?xf32>)
 // CHECK-SAME:                outs(%[[v2]] : memref<?x?xf32>)

 // CHECK-DAG:     %[[c3000:.*]] = constant 3000 : index
 // CHECK-DAG:     %[[c4000:.*]] = constant 4000 : index
 // CHECK:   scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c2000]] {
 // CHECK:     scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c3000]] {
 // CHECK:       scf.for {{.*}} = %[[c0]] to {{.*}} step %[[c4000]] {
 // CHECK:         %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:         %[[s1:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
 // CHECK:         %[[s2:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK:         %[[a0:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK:         %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK:         %[[a0:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK:         %[[v0:.*]] = memref.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK:         %[[l0:.*]] = subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
-// CHECK-NOT:     %[[a1:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK-NOT:     %[[v1:.*]] = std.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK-NOT:     %[[a1:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK-NOT:     %[[v1:.*]] = memref.view %[[a1]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK-NOT:     %[[l0:.*]] = subview %[[v1]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
-// CHECK-NOT:     %[[a2:.*]] = alloc({{%.*}}) : memref<?xi8>
-// CHECK-NOT:     %[[v2:.*]] = std.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK-NOT:     %[[a2:.*]] = memref.alloc({{%.*}}) : memref<?xi8>
+// CHECK-NOT:     %[[v2:.*]] = memref.view %[[a2]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK-NOT:     %[[l0:.*]] = subview %[[v2]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
 // CHECK:         linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK-NOT:     linalg.copy(%[[s1]], %[[l1]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK-NOT:     linalg.copy(%[[s2]], %[[l2]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>^
 // CHECK:         linalg.matmul
 // CHECK-SAME:           ins(%[[v0]], %[[s1]] : memref<?x?xf32>, memref<?x?xf32, #[[$STRIDED_2D]]>)
 // CHECK-SAME:          outs(%[[s2]] : memref<?x?xf32, #[[$STRIDED_2D]]>)
 
 func @aligned_promote_fill(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
   %c2000 = constant 2000 : index
   %c4000 = constant 4000 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %cf = constant 1.0 : f32
   %3 = std.subview %arg0[%c0, %c0][%c2000, %c4000][%c1, %c1] :
    memref<?x?xf32, offset: ?, strides: [?, 1]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
   linalg.fill(%3, %cf) { __internal_linalg_transform__ = "_promote_views_aligned_"}
     :  memref<?x?xf32, offset: ?, strides: [?, ?]>, f32
   return
 }
 // CHECK-LABEL: func @aligned_promote_fill
 // CHECK:   %[[cf:.*]] = constant {{.*}} : f32
 // CHECK:         %[[s0:.*]] = subview {{%.*}}[{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] [{{%.*}}, {{%.*}}] : memref<?x?xf32, #map{{.*}}> to memref<?x?xf32, #map{{.*}}>
-// CHECK:         %[[a0:.*]] = alloc({{%.*}}) {alignment = 32 : i64} : memref<?xi8>
-// CHECK:         %[[v0:.*]] = std.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
+// CHECK:         %[[a0:.*]] = memref.alloc({{%.*}}) {alignment = 32 : i64} : memref<?xi8>
+// CHECK:         %[[v0:.*]] = memref.view %[[a0]][{{.*}}][{{%.*}}, {{%.*}}] : memref<?xi8> to memref<?x?xf32>
 // CHECK:         %[[l0:.*]] = subview %[[v0]][0, 0] [%{{.*}}, %{{.*}}] [1, 1] : memref<?x?xf32> to memref<?x?xf32, #[[$STRIDED_2D_u_1]]>
 // CHECK:         linalg.fill(%[[v0]], {{%.*}}) : memref<?x?xf32>, f32
 // CHECK:         linalg.copy(%[[s0]], %[[l0]]) : memref<?x?xf32, #map{{.*}}>, memref<?x?xf32, #map{{.*}}>
 // CHECK:         linalg.fill(%[[v0]], %[[cf]]) : memref<?x?xf32>, f32
 
 func @tile_permute_parallel_loop(%arg0: memref<?x?xf32>,
                                  %arg1: memref<?x?xf32>,
                                  %arg2: memref<?x?xf32>) {

mlir/test/Dialect/OpenACC/invalid.mlir

 // -----
 
 // expected-error@+1 {{at least one value must be present in hostOperands or deviceOperands}}
 acc.update
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
 acc.update wait_devnum(%cst: index) host(%value: memref<10xf32>)
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{async attribute cannot appear with  asyncOperand}}
 acc.update async(%cst: index) host(%value: memref<10xf32>) attributes {async}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait attribute cannot appear with waitOperands}}
 acc.update wait(%cst: index) host(%value: memref<10xf32>) attributes {wait}
 
 // -----
 
 %cst = constant 1 : index
 // expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
 acc.wait wait_devnum(%cst: index)

 // -----
 
 // expected-error@+1 {{at least one operand in copyout, delete or detach must appear on the exit data operation}}
 acc.exit_data attributes {async}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{async attribute cannot appear with asyncOperand}}
 acc.exit_data async(%cst: index) delete(%value : memref<10xf32>) attributes {async}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
 acc.exit_data wait_devnum(%cst: index) delete(%value : memref<10xf32>)
 
 // -----
 
 // expected-error@+1 {{at least one operand in copyin, create, create_zero or attach must appear on the enter data operation}}
 acc.enter_data attributes {async}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{async attribute cannot appear with asyncOperand}}
 acc.enter_data async(%cst: index) create(%value : memref<10xf32>) attributes {async}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait attribute cannot appear with waitOperands}}
 acc.enter_data wait(%cst: index) create(%value : memref<10xf32>) attributes {wait}
 
 // -----
 
 %cst = constant 1 : index
-%value = alloc() : memref<10xf32>
+%value = memref.alloc() : memref<10xf32>
 // expected-error@+1 {{wait_devnum cannot appear without waitOperands}}
 acc.enter_data wait_devnum(%cst: index) create(%value : memref<10xf32>)

mlir/test/Dialect/OpenACC/ops.mlir

acc.loop gang vector {
       scf.for %arg3 = %c0 to %c10 step %c1 {
         scf.for %arg4 = %c0 to %c10 step %c1 {
           scf.for %arg5 = %c0 to %c10 step %c1 {
             %a = load %A[%arg3, %arg5] : memref<10x10xf32>
             %b = load %B[%arg5, %arg4] : memref<10x10xf32>
             %cij = load %C[%arg3, %arg4] : memref<10x10xf32>
             %p = mulf %a, %b : f32
             %co = addf %cij, %p : f32
-            store %co, %C[%arg3, %arg4] : memref<10x10xf32>
+            memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
           }
         }
       }
       acc.yield
     } attributes { collapse = 3 }
     acc.yield
   }
 

 //  CHECK-NEXT:       scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:         scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:           scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
 //  CHECK-NEXT:             %{{.*}} = addf %{{.*}}, %{{.*}} : f32
-//  CHECK-NEXT:             store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
+//  CHECK-NEXT:             memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:           }
 //  CHECK-NEXT:         }
 //  CHECK-NEXT:       }
 //  CHECK-NEXT:       acc.yield
 //  CHECK-NEXT:     } attributes {collapse = 3 : i64}
 //  CHECK-NEXT:     acc.yield
 //  CHECK-NEXT:   }
 //  CHECK-NEXT:   return %{{.*}} : memref<10x10xf32>
acc.loop {
       scf.for %arg3 = %c0 to %c10 step %c1 {
         scf.for %arg4 = %c0 to %c10 step %c1 {
           scf.for %arg5 = %c0 to %c10 step %c1 {
             %a = load %A[%arg3, %arg5] : memref<10x10xf32>
             %b = load %B[%arg5, %arg4] : memref<10x10xf32>
             %cij = load %C[%arg3, %arg4] : memref<10x10xf32>
             %p = mulf %a, %b : f32
             %co = addf %cij, %p : f32
-            store %co, %C[%arg3, %arg4] : memref<10x10xf32>
+            memref.store %co, %C[%arg3, %arg4] : memref<10x10xf32>
           }
         }
       }
       acc.yield
     } attributes {seq}
     acc.yield
   }
 

 //  CHECK-NEXT:       scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:         scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:           scf.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:             %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
 //  CHECK-NEXT:             %{{.*}} = addf %{{.*}}, %{{.*}} : f32
-//  CHECK-NEXT:             store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
+//  CHECK-NEXT:             memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 //  CHECK-NEXT:           }
 //  CHECK-NEXT:         }
 //  CHECK-NEXT:       }
 //  CHECK-NEXT:       acc.yield
 //  CHECK-NEXT:     } attributes {seq}
 //  CHECK-NEXT:     acc.yield
 //  CHECK-NEXT:   }
 //  CHECK-NEXT:   return %{{.*}} : memref<10x10xf32>
acc.data present(%a, %b, %c, %d: memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) {
     acc.parallel num_gangs(%numGangs: i64) num_workers(%numWorkers: i64) private(%c : memref<10xf32>) {
       acc.loop gang {
         scf.for %x = %lb to %c10 step %st {
           acc.loop worker {
             scf.for %y = %lb to %c10 step %st {
               %axy = load %a[%x, %y] : memref<10x10xf32>
               %bxy = load %b[%x, %y] : memref<10x10xf32>
               %tmp = addf %axy, %bxy : f32
-              store %tmp, %c[%y] : memref<10xf32>
+              memref.store %tmp, %c[%y] : memref<10xf32>
             }
             acc.yield
           }
 
           acc.loop {
             // for i = 0 to 10 step 1
             //   d[x] += c[i]
             scf.for %i = %lb to %c10 step %st {
               %ci = load %c[%i] : memref<10xf32>
               %dx = load %d[%x] : memref<10xf32>
               %z = addf %ci, %dx : f32
-              store %z, %d[%x] : memref<10xf32>
+              memref.store %z, %d[%x] : memref<10xf32>
             }
             acc.yield
           } attributes {seq}
         }
         acc.yield
       }
       acc.yield
     }

 // CHECK-NEXT:     acc.parallel num_gangs([[NUMGANG]]: i64) num_workers([[NUMWORKERS]]: i64) private([[ARG2]]: memref<10xf32>) {
 // CHECK-NEXT:       acc.loop gang {
 // CHECK-NEXT:         scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
 // CHECK-NEXT:           acc.loop worker {
 // CHECK-NEXT:             scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
 // CHECK-NEXT:               %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 // CHECK-NEXT:               %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 // CHECK-NEXT:               %{{.*}} = addf %{{.*}}, %{{.*}} : f32
-// CHECK-NEXT:               store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
+// CHECK-NEXT:               memref.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:             }
 // CHECK-NEXT:             acc.yield
 // CHECK-NEXT:           }
 // CHECK-NEXT:           acc.loop {
 // CHECK-NEXT:             scf.for %{{.*}} = [[C0]] to [[C10]] step [[C1]] {
 // CHECK-NEXT:               %{{.*}} = load %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:               %{{.*}} = load %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:               %{{.*}} = addf %{{.*}}, %{{.*}} : f32
-// CHECK-NEXT:               store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
+// CHECK-NEXT:               memref.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:             }
 // CHECK-NEXT:             acc.yield
 // CHECK-NEXT:           } attributes {seq}
 // CHECK-NEXT:         }
 // CHECK-NEXT:         acc.yield
 // CHECK-NEXT:       }
 // CHECK-NEXT:       acc.yield
 // CHECK-NEXT:     }

mlir/test/Dialect/SCF/canonicalize.mlir

 // RUN: mlir-opt %s -pass-pipeline='func(canonicalize)' | FileCheck %s
 
 func @single_iteration(%A: memref<?x?x?xi32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c3 = constant 3 : index
   %c6 = constant 6 : index
   %c7 = constant 7 : index
   %c10 = constant 10 : index
   scf.parallel (%i0, %i1, %i2) = (%c0, %c3, %c7) to (%c1, %c6, %c10) step (%c1, %c2, %c3) {
     %c42 = constant 42 : i32
-    store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32>
+    memref.store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32>
     scf.yield
   }
   return
 }
 
 // CHECK-LABEL:   func @single_iteration(
 // CHECK-SAME:                        [[ARG0:%.*]]: memref<?x?x?xi32>) {
 // CHECK:           [[C0:%.*]] = constant 0 : index
 // CHECK:           [[C2:%.*]] = constant 2 : index
 // CHECK:           [[C3:%.*]] = constant 3 : index
 // CHECK:           [[C6:%.*]] = constant 6 : index
 // CHECK:           [[C7:%.*]] = constant 7 : index
 // CHECK:           [[C42:%.*]] = constant 42 : i32
 // CHECK:           scf.parallel ([[V0:%.*]]) = ([[C3]]) to ([[C6]]) step ([[C2]]) {
-// CHECK:             store [[C42]], [[ARG0]]{{\[}}[[C0]], [[V0]], [[C7]]] : memref<?x?x?xi32>
+// CHECK:             memref.store [[C42]], [[ARG0]]{{\[}}[[C0]], [[V0]], [[C7]]] : memref<?x?x?xi32>
 // CHECK:             scf.yield
 // CHECK:           }
 // CHECK:           return
 
 // -----
 
 func @one_unused(%cond: i1) -> (index) {
   %c0 = constant 0 : index

mlir/test/Dialect/SCF/for-loop-specialization.mlir

 // RUN: mlir-opt %s -for-loop-specialization -split-input-file | FileCheck %s
 
 #map0 = affine_map<()[s0, s1] -> (1024, s0 - s1)>
 #map1 = affine_map<()[s0, s1] -> (64, s0 - s1)>
 
 func @for(%outer: index, %A: memref<?xf32>, %B: memref<?xf32>,
           %C: memref<?xf32>, %result: memref<?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %d0 = dim %A, %c0 : memref<?xf32>
   %b0 = affine.min #map0()[%d0, %outer]
   scf.for %i0 = %c0 to %b0 step %c1 {
     %B_elem = load %B[%i0] : memref<?xf32>
     %C_elem = load %C[%i0] : memref<?xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %result[%i0] : memref<?xf32>
+    memref.store %sum_elem, %result[%i0] : memref<?xf32>
   }
   return
 }
 
 // CHECK-LABEL:   func @for(
 // CHECK-SAME:              [[ARG0:%.*]]: index, [[ARG1:%.*]]: memref<?xf32>, [[ARG2:%.*]]: memref<?xf32>, [[ARG3:%.*]]: memref<?xf32>, [[ARG4:%.*]]: memref<?xf32>) {
 // CHECK:           [[CST_0:%.*]] = constant 0 : index
 // CHECK:           [[CST_1:%.*]] = constant 1 : index
 // CHECK:           [[DIM_0:%.*]] = dim [[ARG1]], [[CST_0]] : memref<?xf32>
 // CHECK:           [[MIN:%.*]] = affine.min #map(){{\[}}[[DIM_0]], [[ARG0]]]
 // CHECK:           [[CST_1024:%.*]] = constant 1024 : index
 // CHECK:           [[PRED:%.*]] = cmpi eq, [[MIN]], [[CST_1024]] : index
 // CHECK:           scf.if [[PRED]] {
 // CHECK:             scf.for [[IDX0:%.*]] = [[CST_0]] to [[CST_1024]] step [[CST_1]] {
-// CHECK:               store
+// CHECK:               memref.store
 // CHECK:             }
 // CHECK:           } else {
 // CHECK:             scf.for [[IDX0:%.*]] = [[CST_0]] to [[MIN]] step [[CST_1]] {
-// CHECK:               store
+// CHECK:               memref.store
 // CHECK:             }
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }

mlir/test/Dialect/SCF/loop-unroll.mlir

 // RUN: mlir-opt %s -test-loop-unrolling='unroll-factor=2' | FileCheck %s --check-prefix UNROLL-BY-2
 // RUN: mlir-opt %s -test-loop-unrolling='unroll-factor=3' | FileCheck %s --check-prefix UNROLL-BY-3
 // RUN: mlir-opt %s -test-loop-unrolling='unroll-factor=2 loop-depth=0' | FileCheck %s --check-prefix UNROLL-OUTER-BY-2
 // RUN: mlir-opt %s -test-loop-unrolling='unroll-factor=2 loop-depth=1' | FileCheck %s --check-prefix UNROLL-INNER-BY-2
 // RUN: mlir-opt %s --affine-loop-unroll='unroll-factor=6 unroll-up-to-factor=true' | FileCheck %s --check-prefix UNROLL-UP-TO
 
 func @dynamic_loop_unroll(%arg0 : index, %arg1 : index, %arg2 : index,
                           %arg3: memref<?xf32>) {
   %0 = constant 7.0 : f32
   scf.for %i0 = %arg0 to %arg1 step %arg2 {
-    store %0, %arg3[%i0] : memref<?xf32>
+    memref.store %0, %arg3[%i0] : memref<?xf32>
   }
   return
 }
 // UNROLL-BY-2-LABEL: func @dynamic_loop_unroll
 //  UNROLL-BY-2-SAME:  %[[LB:.*0]]: index,
 //  UNROLL-BY-2-SAME:  %[[UB:.*1]]: index,
 //  UNROLL-BY-2-SAME:  %[[STEP:.*2]]: index,
 //  UNROLL-BY-2-SAME:  %[[MEM:.*3]]: memref<?xf32>

 //   UNROLL-BY-2-DAG:  %[[V4:.*]] = remi_signed %[[V3]], %[[C2]] : index
 //   UNROLL-BY-2-DAG:  %[[V5:.*]] = subi %[[V3]], %[[V4]] : index
 //   UNROLL-BY-2-DAG:  %[[V6:.*]] = muli %[[V5]], %[[STEP]] : index
 //       Compute upper bound of unrolled loop in V7.
 //   UNROLL-BY-2-DAG:  %[[V7:.*]] = addi %[[LB]], %[[V6]] : index
 //       Compute step of unrolled loop in V8.
 //   UNROLL-BY-2-DAG:  %[[V8:.*]] = muli %[[STEP]], %[[C2]] : index
 //       UNROLL-BY-2:  scf.for %[[IV:.*]] = %[[LB]] to %[[V7]] step %[[V8]] {
-//  UNROLL-BY-2-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-2-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-2-NEXT:    %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-BY-2-NEXT:    %[[V9:.*]] = muli %[[STEP]], %[[C1_IV]] : index
 //  UNROLL-BY-2-NEXT:    %[[V10:.*]] = addi %[[IV]], %[[V9]] : index
-//  UNROLL-BY-2-NEXT:    store %{{.*}}, %[[MEM]][%[[V10]]] : memref<?xf32>
+//  UNROLL-BY-2-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V10]]] : memref<?xf32>
 //  UNROLL-BY-2-NEXT:  }
 //  UNROLL-BY-2-NEXT:  scf.for %[[IV:.*]] = %[[V7]] to %[[UB]] step %[[STEP]] {
-//  UNROLL-BY-2-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-2-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-2-NEXT:  }
 //  UNROLL-BY-2-NEXT:  return
 
 // UNROLL-BY-3-LABEL: func @dynamic_loop_unroll
 //  UNROLL-BY-3-SAME:  %[[LB:.*0]]: index,
 //  UNROLL-BY-3-SAME:  %[[UB:.*1]]: index,
 //  UNROLL-BY-3-SAME:  %[[STEP:.*2]]: index,
 //  UNROLL-BY-3-SAME:  %[[MEM:.*3]]: memref<?xf32>

 //   UNROLL-BY-3-DAG:  %[[V4:.*]] = remi_signed %[[V3]], %[[C3]] : index
 //   UNROLL-BY-3-DAG:  %[[V5:.*]] = subi %[[V3]], %[[V4]] : index
 //   UNROLL-BY-3-DAG:  %[[V6:.*]] = muli %[[V5]], %[[STEP]] : index
 //       Compute upper bound of unrolled loop in V7.
 //   UNROLL-BY-3-DAG:  %[[V7:.*]] = addi %[[LB]], %[[V6]] : index
 //       Compute step of unrolled loop in V8.
 //   UNROLL-BY-3-DAG:  %[[V8:.*]] = muli %[[STEP]], %[[C3]] : index
 //       UNROLL-BY-3:  scf.for %[[IV:.*]] = %[[LB]] to %[[V7]] step %[[V8]] {
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-BY-3-NEXT:    %[[V9:.*]] = muli %[[STEP]], %[[C1_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V10:.*]] = addi %[[IV]], %[[V9]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V10]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V10]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C2_IV:.*]] = constant 2 : index
 //  UNROLL-BY-3-NEXT:    %[[V11:.*]] = muli %[[STEP]], %[[C2_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V12:.*]] = addi %[[IV]], %[[V11]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V12]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V12]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  }
 //  UNROLL-BY-3-NEXT:  scf.for %[[IV:.*]] = %[[V7]] to %[[UB]] step %[[STEP]] {
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  }
 //  UNROLL-BY-3-NEXT:  return
 
 func @dynamic_loop_unroll_outer_by_2(
   %arg0 : index, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index,
   %arg5 : index, %arg6: memref<?xf32>) {
   %0 = constant 7.0 : f32
   scf.for %i0 = %arg0 to %arg1 step %arg2 {
     scf.for %i1 = %arg3 to %arg4 step %arg5 {
-     store %0, %arg6[%i1] : memref<?xf32>
+     memref.store %0, %arg6[%i1] : memref<?xf32>
     }
   }
   return
 }
 // UNROLL-OUTER-BY-2-LABEL: func @dynamic_loop_unroll_outer_by_2
 //  UNROLL-OUTER-BY-2-SAME:  %[[LB0:.*0]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[UB0:.*1]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[STEP0:.*2]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[LB1:.*3]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[UB1:.*4]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[STEP1:.*5]]: index,
 //  UNROLL-OUTER-BY-2-SAME:  %[[MEM:.*6]]: memref<?xf32>
 //
 //       UNROLL-OUTER-BY-2:  scf.for %[[IV0:.*]] = %[[LB0]] to %{{.*}} step %{{.*}} {
 //  UNROLL-OUTER-BY-2-NEXT:    scf.for %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] {
-//  UNROLL-OUTER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
+//  UNROLL-OUTER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
 //  UNROLL-OUTER-BY-2-NEXT:    }
 //  UNROLL-OUTER-BY-2-NEXT:    scf.for %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] {
-//  UNROLL-OUTER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
+//  UNROLL-OUTER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
 //  UNROLL-OUTER-BY-2-NEXT:    }
 //  UNROLL-OUTER-BY-2-NEXT:  }
 //  UNROLL-OUTER-BY-2-NEXT:  scf.for %[[IV0:.*]] = %{{.*}} to %[[UB0]] step %[[STEP0]] {
 //  UNROLL-OUTER-BY-2-NEXT:    scf.for %[[IV1:.*]] = %[[LB1]] to %[[UB1]] step %[[STEP1]] {
-//  UNROLL-OUTER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
+//  UNROLL-OUTER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
 //  UNROLL-OUTER-BY-2-NEXT:    }
 //  UNROLL-OUTER-BY-2-NEXT:  }
 //  UNROLL-OUTER-BY-2-NEXT:  return
 
 func @dynamic_loop_unroll_inner_by_2(
   %arg0 : index, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index,
   %arg5 : index, %arg6: memref<?xf32>) {
   %0 = constant 7.0 : f32
   scf.for %i0 = %arg0 to %arg1 step %arg2 {
     scf.for %i1 = %arg3 to %arg4 step %arg5 {
-     store %0, %arg6[%i1] : memref<?xf32>
+     memref.store %0, %arg6[%i1] : memref<?xf32>
     }
   }
   return
 }
 // UNROLL-INNER-BY-2-LABEL: func @dynamic_loop_unroll_inner_by_2
 //  UNROLL-INNER-BY-2-SAME:  %[[LB0:.*0]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[UB0:.*1]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[STEP0:.*2]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[LB1:.*3]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[UB1:.*4]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[STEP1:.*5]]: index,
 //  UNROLL-INNER-BY-2-SAME:  %[[MEM:.*6]]: memref<?xf32>
 //
 //       UNROLL-INNER-BY-2:  scf.for %[[IV0:.*]] = %[[LB0]] to %[[UB0]] step %[[STEP0]] {
 //       UNROLL-INNER-BY-2:    scf.for %[[IV1:.*]] = %[[LB1]] to %{{.*}} step %{{.*}} {
-//  UNROLL-INNER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
+//  UNROLL-INNER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
 //  UNROLL-INNER-BY-2-NEXT:      %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-INNER-BY-2-NEXT:      %[[V0:.*]] = muli %[[STEP1]], %[[C1_IV]] : index
 //  UNROLL-INNER-BY-2-NEXT:      %[[V1:.*]] = addi %[[IV1]], %[[V0]] : index
-//  UNROLL-INNER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
+//  UNROLL-INNER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //  UNROLL-INNER-BY-2-NEXT:    }
 //  UNROLL-INNER-BY-2-NEXT:    scf.for %[[IV1:.*]] = %{{.*}} to %[[UB1]] step %[[STEP1]] {
-//  UNROLL-INNER-BY-2-NEXT:      store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
+//  UNROLL-INNER-BY-2-NEXT:      memref.store %{{.*}}, %[[MEM]][%[[IV1]]] : memref<?xf32>
 //  UNROLL-INNER-BY-2-NEXT:    }
 //  UNROLL-INNER-BY-2-NEXT:  }
 //  UNROLL-INNER-BY-2-NEXT:  return
 
 // Test that no epilogue clean-up loop is generated because the trip count is
 // a multiple of the unroll factor.
 func @static_loop_unroll_by_2(%arg0 : memref<?xf32>) {
   %0 = constant 7.0 : f32
   %lb = constant 0 : index
   %ub = constant 20 : index
   %step = constant 1 : index
   scf.for %i0 = %lb to %ub step %step {
-    store %0, %arg0[%i0] : memref<?xf32>
+    memref.store %0, %arg0[%i0] : memref<?xf32>
   }
   return
 }
 // UNROLL-BY-2-LABEL: func @static_loop_unroll_by_2
 //  UNROLL-BY-2-SAME:  %[[MEM:.*0]]: memref<?xf32>
 //
 //   UNROLL-BY-2-DAG:  %[[C0:.*]] = constant 0 : index
 //   UNROLL-BY-2-DAG:  %[[C1:.*]] = constant 1 : index
 //   UNROLL-BY-2-DAG:  %[[C20:.*]] = constant 20 : index
 //   UNROLL-BY-2-DAG:  %[[C2:.*]] = constant 2 : index
 //   UNROLL-BY-2:  scf.for %[[IV:.*]] = %[[C0]] to %[[C20]] step %[[C2]] {
-//  UNROLL-BY-2-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-2-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-2-NEXT:    %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-BY-2-NEXT:    %[[V0:.*]] = muli %[[C1]], %[[C1_IV]] : index
 //  UNROLL-BY-2-NEXT:    %[[V1:.*]] = addi %[[IV]], %[[V0]] : index
-//  UNROLL-BY-2-NEXT:    store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
+//  UNROLL-BY-2-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //  UNROLL-BY-2-NEXT:  }
 //  UNROLL-BY-2-NEXT:  return
 
 // Test that epilogue clean up loop is generated (trip count is not
 // a multiple of unroll factor).
 func @static_loop_unroll_by_3(%arg0 : memref<?xf32>) {
   %0 = constant 7.0 : f32
   %lb = constant 0 : index
   %ub = constant 20 : index
   %step = constant 1 : index
   scf.for %i0 = %lb to %ub step %step {
-    store %0, %arg0[%i0] : memref<?xf32>
+    memref.store %0, %arg0[%i0] : memref<?xf32>
   }
   return
 }
 
 // UNROLL-BY-3-LABEL: func @static_loop_unroll_by_3
 //  UNROLL-BY-3-SAME:  %[[MEM:.*0]]: memref<?xf32>
 //
 //   UNROLL-BY-3-DAG:  %[[C0:.*]] = constant 0 : index
 //   UNROLL-BY-3-DAG:  %[[C1:.*]] = constant 1 : index
 //   UNROLL-BY-3-DAG:  %[[C20:.*]] = constant 20 : index
 //   UNROLL-BY-3-DAG:  %[[C18:.*]] = constant 18 : index
 //   UNROLL-BY-3-DAG:  %[[C3:.*]] = constant 3 : index
 //       UNROLL-BY-3: scf.for %[[IV:.*]] = %[[C0]] to %[[C18]] step %[[C3]] {
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-BY-3-NEXT:    %[[V0:.*]] = muli %[[C1]], %[[C1_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V1:.*]] = addi %[[IV]], %[[V0]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C2_IV:.*]] = constant 2 : index
 //  UNROLL-BY-3-NEXT:    %[[V2:.*]] = muli %[[C1]], %[[C2_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V3:.*]] = addi %[[IV]], %[[V2]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V3]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V3]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  }
 //  UNROLL-BY-3-NEXT:  scf.for %[[IV:.*]] = %[[C18]] to %[[C20]] step %[[C1]] {
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  }
 //  UNROLL-BY-3-NEXT:  return
 
 // Test that the single iteration epilogue loop body is promoted to the loops
 // containing block.
 func @static_loop_unroll_by_3_promote_epilogue(%arg0 : memref<?xf32>) {
   %0 = constant 7.0 : f32
   %lb = constant 0 : index
   %ub = constant 10 : index
   %step = constant 1 : index
   scf.for %i0 = %lb to %ub step %step {
-    store %0, %arg0[%i0] : memref<?xf32>
+    memref.store %0, %arg0[%i0] : memref<?xf32>
   }
   return
 }
 // UNROLL-BY-3-LABEL: func @static_loop_unroll_by_3_promote_epilogue
 //  UNROLL-BY-3-SAME:  %[[MEM:.*0]]: memref<?xf32>
 //
 //   UNROLL-BY-3-DAG:  %[[C0:.*]] = constant 0 : index
 //   UNROLL-BY-3-DAG:  %[[C1:.*]] = constant 1 : index
 //   UNROLL-BY-3-DAG:  %[[C10:.*]] = constant 10 : index
 //   UNROLL-BY-3-DAG:  %[[C9:.*]] = constant 9 : index
 //   UNROLL-BY-3-DAG:  %[[C3:.*]] = constant 3 : index
 //       UNROLL-BY-3: scf.for %[[IV:.*]] = %[[C0]] to %[[C9]] step %[[C3]] {
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[IV]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C1_IV:.*]] = constant 1 : index
 //  UNROLL-BY-3-NEXT:    %[[V0:.*]] = muli %[[C1]], %[[C1_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V1:.*]] = addi %[[IV]], %[[V0]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:    %[[C2_IV:.*]] = constant 2 : index
 //  UNROLL-BY-3-NEXT:    %[[V2:.*]] = muli %[[C1]], %[[C2_IV]] : index
 //  UNROLL-BY-3-NEXT:    %[[V3:.*]] = addi %[[IV]], %[[V2]] : index
-//  UNROLL-BY-3-NEXT:    store %{{.*}}, %[[MEM]][%[[V3]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:    memref.store %{{.*}}, %[[MEM]][%[[V3]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  }
-//  UNROLL-BY-3-NEXT:  store %{{.*}}, %[[MEM]][%[[C9]]] : memref<?xf32>
+//  UNROLL-BY-3-NEXT:  memref.store %{{.*}}, %[[MEM]][%[[C9]]] : memref<?xf32>
 //  UNROLL-BY-3-NEXT:  return
 
 // Test unroll-up-to functionality.
 func @static_loop_unroll_up_to_factor(%arg0 : memref<?xf32>) {
   %0 = constant 7.0 : f32
   %lb = constant 0 : index
   %ub = constant 2 : index
   affine.for %i0 = %lb to %ub {
     affine.store %0, %arg0[%i0] : memref<?xf32>
   }
   return
 }
 // UNROLL-UP-TO-LABEL: func @static_loop_unroll_up_to_factor
 //  UNROLL-UP-TO-SAME:  %[[MEM:.*0]]: memref<?xf32>
 //
 //   UNROLL-UP-TO-DAG:  %[[C0:.*]] = constant 0 : index
 //   UNROLL-UP-TO-DAG:  %[[C2:.*]] = constant 2 : index
 //   UNROLL-UP-TO-NEXT: %[[V0:.*]] = affine.apply {{.*}}
 //   UNROLL-UP-TO-NEXT: store %{{.*}}, %[[MEM]][%[[V0]]] : memref<?xf32>
 //   UNROLL-UP-TO-NEXT: %[[V1:.*]] = affine.apply {{.*}}
 //   UNROLL-UP-TO-NEXT: affine.store %{{.*}}, %[[MEM]][%[[V1]]] : memref<?xf32>
 //   UNROLL-UP-TO-NEXT: return
 No newline at end of file

mlir/test/Dialect/SCF/parallel-loop-fusion.mlir

 
 // -----
 
 func @fuse_two(%A: memref<2x2xf32>, %B: memref<2x2xf32>,
                     %C: memref<2x2xf32>, %result: memref<2x2xf32>) {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %sum = alloc()  : memref<2x2xf32>
+  %sum = memref.alloc()  : memref<2x2xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %B_elem = load %B[%i, %j] : memref<2x2xf32>
     %C_elem = load %C[%i, %j] : memref<2x2xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
+    memref.store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %sum_elem = load %sum[%i, %j] : memref<2x2xf32>
     %A_elem = load %A[%i, %j] : memref<2x2xf32>
     %product_elem = mulf %sum_elem, %A_elem : f32
-    store %product_elem, %result[%i, %j] : memref<2x2xf32>
+    memref.store %product_elem, %result[%i, %j] : memref<2x2xf32>
     scf.yield
   }
-  dealloc %sum : memref<2x2xf32>
+  memref.dealloc %sum : memref<2x2xf32>
   return
 }
 // CHECK-LABEL: func @fuse_two
 // CHECK-SAME:   ([[A:%.*]]: {{.*}}, [[B:%.*]]: {{.*}}, [[C:%.*]]: {{.*}},
 // CHECK-SAME:    [[RESULT:%.*]]: {{.*}}) {
 // CHECK:      [[C2:%.*]] = constant 2 : index
 // CHECK:      [[C0:%.*]] = constant 0 : index
 // CHECK:      [[C1:%.*]] = constant 1 : index
-// CHECK:      [[SUM:%.*]] = alloc()
+// CHECK:      [[SUM:%.*]] = memref.alloc()
 // CHECK:      scf.parallel ([[I:%.*]], [[J:%.*]]) = ([[C0]], [[C0]])
 // CHECK-SAME:     to ([[C2]], [[C2]]) step ([[C1]], [[C1]]) {
 // CHECK:        [[B_ELEM:%.*]] = load [[B]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[C_ELEM:%.*]] = load [[C]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[SUM_ELEM:%.*]] = addf [[B_ELEM]], [[C_ELEM]]
-// CHECK:        store [[SUM_ELEM]], [[SUM]]{{\[}}[[I]], [[J]]]
+// CHECK:        memref.store [[SUM_ELEM]], [[SUM]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[SUM_ELEM_:%.*]] = load [[SUM]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[A_ELEM:%.*]] = load [[A]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[PRODUCT_ELEM:%.*]] = mulf [[SUM_ELEM_]], [[A_ELEM]]
-// CHECK:        store [[PRODUCT_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
+// CHECK:        memref.store [[PRODUCT_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
 // CHECK:        scf.yield
 // CHECK:      }
-// CHECK:      dealloc [[SUM]]
+// CHECK:      memref.dealloc [[SUM]]
 
 // -----
 
 func @fuse_three(%lhs: memref<100x10xf32>, %rhs: memref<100xf32>,
                       %result: memref<100x10xf32>) {
   %c100 = constant 100 : index
   %c10 = constant 10 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %broadcast_rhs = alloc() : memref<100x10xf32>
-  %diff = alloc() : memref<100x10xf32>
+  %broadcast_rhs = memref.alloc() : memref<100x10xf32>
+  %diff = memref.alloc() : memref<100x10xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c100, %c10) step (%c1, %c1) {
     %rhs_elem = load %rhs[%i] : memref<100xf32>
-    store %rhs_elem, %broadcast_rhs[%i, %j] : memref<100x10xf32>
+    memref.store %rhs_elem, %broadcast_rhs[%i, %j] : memref<100x10xf32>
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c100, %c10) step (%c1, %c1) {
     %lhs_elem = load %lhs[%i, %j] : memref<100x10xf32>
     %broadcast_rhs_elem = load %broadcast_rhs[%i, %j] : memref<100x10xf32>
     %diff_elem = subf %lhs_elem, %broadcast_rhs_elem : f32
-    store %diff_elem, %diff[%i, %j] : memref<100x10xf32>
+    memref.store %diff_elem, %diff[%i, %j] : memref<100x10xf32>
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c100, %c10) step (%c1, %c1) {
     %diff_elem = load %diff[%i, %j] : memref<100x10xf32>
     %exp_elem = math.exp %diff_elem : f32
-    store %exp_elem, %result[%i, %j] : memref<100x10xf32>
+    memref.store %exp_elem, %result[%i, %j] : memref<100x10xf32>
     scf.yield
   }
-  dealloc %broadcast_rhs : memref<100x10xf32>
-  dealloc %diff : memref<100x10xf32>
+  memref.dealloc %broadcast_rhs : memref<100x10xf32>
+  memref.dealloc %diff : memref<100x10xf32>
   return
 }
 // CHECK-LABEL: func @fuse_three
 // CHECK-SAME: ([[LHS:%.*]]: memref<100x10xf32>, [[RHS:%.*]]: memref<100xf32>,
 // CHECK-SAME:  [[RESULT:%.*]]: memref<100x10xf32>) {
 // CHECK:      [[C100:%.*]] = constant 100 : index
 // CHECK:      [[C10:%.*]] = constant 10 : index
 // CHECK:      [[C0:%.*]] = constant 0 : index
 // CHECK:      [[C1:%.*]] = constant 1 : index
-// CHECK:      [[BROADCAST_RHS:%.*]] = alloc()
-// CHECK:      [[DIFF:%.*]] = alloc()
+// CHECK:      [[BROADCAST_RHS:%.*]] = memref.alloc()
+// CHECK:      [[DIFF:%.*]] = memref.alloc()
 // CHECK:      scf.parallel ([[I:%.*]], [[J:%.*]]) = ([[C0]], [[C0]])
 // CHECK-SAME:     to ([[C100]], [[C10]]) step ([[C1]], [[C1]]) {
 // CHECK:        [[RHS_ELEM:%.*]] = load [[RHS]]{{\[}}[[I]]]
-// CHECK:        store [[RHS_ELEM]], [[BROADCAST_RHS]]{{\[}}[[I]], [[J]]]
+// CHECK:        memref.store [[RHS_ELEM]], [[BROADCAST_RHS]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[LHS_ELEM:%.*]] = load [[LHS]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[BROADCAST_RHS_ELEM:%.*]] = load [[BROADCAST_RHS]]
 // CHECK:        [[DIFF_ELEM:%.*]] = subf [[LHS_ELEM]], [[BROADCAST_RHS_ELEM]]
-// CHECK:        store [[DIFF_ELEM]], [[DIFF]]{{\[}}[[I]], [[J]]]
+// CHECK:        memref.store [[DIFF_ELEM]], [[DIFF]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[DIFF_ELEM_:%.*]] = load [[DIFF]]{{\[}}[[I]], [[J]]]
 // CHECK:        [[EXP_ELEM:%.*]] = math.exp [[DIFF_ELEM_]]
-// CHECK:        store [[EXP_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
+// CHECK:        memref.store [[EXP_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
 // CHECK:        scf.yield
 // CHECK:      }
-// CHECK:      dealloc [[BROADCAST_RHS]]
-// CHECK:      dealloc [[DIFF]]
+// CHECK:      memref.dealloc [[BROADCAST_RHS]]
+// CHECK:      memref.dealloc [[DIFF]]
 
 // -----
 
 func @do_not_fuse_nested_ploop1() {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {

 
 func @do_not_fuse_loops_with_side_effecting_ops_in_between() {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     scf.yield
   }
-  %buffer  = alloc() : memref<2x2xf32>
+  %buffer  = memref.alloc() : memref<2x2xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     scf.yield
   }
   return
 }
 // CHECK-LABEL: func @do_not_fuse_loops_with_side_effecting_ops_in_between
 // CHECK:        scf.parallel
 // CHECK:        scf.parallel

 // -----
 
 func @do_not_fuse_unmatching_write_read_patterns(
     %A: memref<2x2xf32>, %B: memref<2x2xf32>,
     %C: memref<2x2xf32>, %result: memref<2x2xf32>) {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %common_buf = alloc() : memref<2x2xf32>
+  %common_buf = memref.alloc() : memref<2x2xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %B_elem = load %B[%i, %j] : memref<2x2xf32>
     %C_elem = load %C[%i, %j] : memref<2x2xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %common_buf[%i, %j] : memref<2x2xf32>
+    memref.store %sum_elem, %common_buf[%i, %j] : memref<2x2xf32>
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %k = addi %i, %c1 : index
     %sum_elem = load %common_buf[%k, %j] : memref<2x2xf32>
     %A_elem = load %A[%i, %j] : memref<2x2xf32>
     %product_elem = mulf %sum_elem, %A_elem : f32
-    store %product_elem, %result[%i, %j] : memref<2x2xf32>
+    memref.store %product_elem, %result[%i, %j] : memref<2x2xf32>
     scf.yield
   }
-  dealloc %common_buf : memref<2x2xf32>
+  memref.dealloc %common_buf : memref<2x2xf32>
   return
 }
 // CHECK-LABEL: func @do_not_fuse_unmatching_write_read_patterns
 // CHECK:        scf.parallel
 // CHECK:        scf.parallel
 
 // -----
 
 func @do_not_fuse_unmatching_read_write_patterns(
     %A: memref<2x2xf32>, %B: memref<2x2xf32>, %common_buf: memref<2x2xf32>) {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %sum = alloc() : memref<2x2xf32>
+  %sum = memref.alloc() : memref<2x2xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %B_elem = load %B[%i, %j] : memref<2x2xf32>
     %C_elem = load %common_buf[%i, %j] : memref<2x2xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
+    memref.store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %k = addi %i, %c1 : index
     %sum_elem = load %sum[%k, %j] : memref<2x2xf32>
     %A_elem = load %A[%i, %j] : memref<2x2xf32>
     %product_elem = mulf %sum_elem, %A_elem : f32
-    store %product_elem, %common_buf[%j, %i] : memref<2x2xf32>
+    memref.store %product_elem, %common_buf[%j, %i] : memref<2x2xf32>
     scf.yield
   }
-  dealloc %sum : memref<2x2xf32>
+  memref.dealloc %sum : memref<2x2xf32>
   return
 }
 // CHECK-LABEL: func @do_not_fuse_unmatching_read_write_patterns
 // CHECK:        scf.parallel
 // CHECK:        scf.parallel
 
 // -----
 
 func @do_not_fuse_loops_with_memref_defined_in_loop_bodies() {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %buffer  = alloc() : memref<2x2xf32>
+  %buffer  = memref.alloc() : memref<2x2xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     scf.yield
   }
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     %A = subview %buffer[%c0, %c0][%c2, %c2][%c1, %c1]
       : memref<2x2xf32> to memref<?x?xf32, offset: ?, strides:[?, ?]>
     %A_elem = load %A[%i, %j] : memref<?x?xf32, offset: ?, strides:[?, ?]>
     scf.yield
   }
   return
 }
 // CHECK-LABEL: func @do_not_fuse_loops_with_memref_defined_in_loop_bodies
 // CHECK:        scf.parallel
 // CHECK:        scf.parallel
 
 // -----
 
 func @nested_fuse(%A: memref<2x2xf32>, %B: memref<2x2xf32>,
                     %C: memref<2x2xf32>, %result: memref<2x2xf32>) {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %sum = alloc()  : memref<2x2xf32>
+  %sum = memref.alloc()  : memref<2x2xf32>
   scf.parallel (%k) = (%c0) to (%c2) step (%c1) {
     scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
       %B_elem = load %B[%i, %j] : memref<2x2xf32>
       %C_elem = load %C[%i, %j] : memref<2x2xf32>
       %sum_elem = addf %B_elem, %C_elem : f32
-      store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
+      memref.store %sum_elem, %sum[%i, %j] : memref<2x2xf32>
       scf.yield
     }
     scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
       %sum_elem = load %sum[%i, %j] : memref<2x2xf32>
       %A_elem = load %A[%i, %j] : memref<2x2xf32>
       %product_elem = mulf %sum_elem, %A_elem : f32
-      store %product_elem, %result[%i, %j] : memref<2x2xf32>
+      memref.store %product_elem, %result[%i, %j] : memref<2x2xf32>
       scf.yield
     }
   }
-  dealloc %sum : memref<2x2xf32>
+  memref.dealloc %sum : memref<2x2xf32>
   return
 }
 // CHECK-LABEL: func @nested_fuse
 // CHECK-SAME:   ([[A:%.*]]: {{.*}}, [[B:%.*]]: {{.*}}, [[C:%.*]]: {{.*}},
 // CHECK-SAME:    [[RESULT:%.*]]: {{.*}}) {
 // CHECK:      [[C2:%.*]] = constant 2 : index
 // CHECK:      [[C0:%.*]] = constant 0 : index
 // CHECK:      [[C1:%.*]] = constant 1 : index
-// CHECK:      [[SUM:%.*]] = alloc()
+// CHECK:      [[SUM:%.*]] = memref.alloc()
 // CHECK:      scf.parallel
 // CHECK:        scf.parallel ([[I:%.*]], [[J:%.*]]) = ([[C0]], [[C0]])
 // CHECK-SAME:       to ([[C2]], [[C2]]) step ([[C1]], [[C1]]) {
 // CHECK:          [[B_ELEM:%.*]] = load [[B]]{{\[}}[[I]], [[J]]]
 // CHECK:          [[C_ELEM:%.*]] = load [[C]]{{\[}}[[I]], [[J]]]
 // CHECK:          [[SUM_ELEM:%.*]] = addf [[B_ELEM]], [[C_ELEM]]
-// CHECK:          store [[SUM_ELEM]], [[SUM]]{{\[}}[[I]], [[J]]]
+// CHECK:          memref.store [[SUM_ELEM]], [[SUM]]{{\[}}[[I]], [[J]]]
 // CHECK:          [[SUM_ELEM_:%.*]] = load [[SUM]]{{\[}}[[I]], [[J]]]
 // CHECK:          [[A_ELEM:%.*]] = load [[A]]{{\[}}[[I]], [[J]]]
 // CHECK:          [[PRODUCT_ELEM:%.*]] = mulf [[SUM_ELEM_]], [[A_ELEM]]
-// CHECK:          store [[PRODUCT_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
+// CHECK:          memref.store [[PRODUCT_ELEM]], [[RESULT]]{{\[}}[[I]], [[J]]]
 // CHECK:          scf.yield
 // CHECK:        }
 // CHECK:      }
-// CHECK:      dealloc [[SUM]]
+// CHECK:      memref.dealloc [[SUM]]

mlir/test/Dialect/SCF/parallel-loop-specialization.mlir

func @parallel_loop(%outer_i0: index, %outer_i1: index, %A: memref<?x?xf32>, %B: memref<?x?xf32>,
   %d0 = dim %A, %c0 : memref<?x?xf32>
   %d1 = dim %A, %c1 : memref<?x?xf32>
   %b0 = affine.min #map0()[%d0, %outer_i0]
   %b1 = affine.min #map1()[%d1, %outer_i1]
   scf.parallel (%i0, %i1) = (%c0, %c0) to (%b0, %b1) step (%c1, %c1) {
     %B_elem = load %B[%i0, %i1] : memref<?x?xf32>
     %C_elem = load %C[%i0, %i1] : memref<?x?xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %result[%i0, %i1] : memref<?x?xf32>
+    memref.store %sum_elem, %result[%i0, %i1] : memref<?x?xf32>
   }
   return
 }
 
 // CHECK-LABEL:   func @parallel_loop(
 // CHECK-SAME:                        [[VAL_0:%.*]]: index, [[VAL_1:%.*]]: index, [[VAL_2:%.*]]: memref<?x?xf32>, [[VAL_3:%.*]]: memref<?x?xf32>, [[VAL_4:%.*]]: memref<?x?xf32>, [[VAL_5:%.*]]: memref<?x?xf32>) {
 // CHECK:           [[VAL_6:%.*]] = constant 0 : index
 // CHECK:           [[VAL_7:%.*]] = constant 1 : index
 // CHECK:           [[VAL_8:%.*]] = dim [[VAL_2]], [[VAL_6]] : memref<?x?xf32>
 // CHECK:           [[VAL_9:%.*]] = dim [[VAL_2]], [[VAL_7]] : memref<?x?xf32>
 // CHECK:           [[VAL_10:%.*]] = affine.min #map0(){{\[}}[[VAL_8]], [[VAL_0]]]
 // CHECK:           [[VAL_11:%.*]] = affine.min #map1(){{\[}}[[VAL_9]], [[VAL_1]]]
 // CHECK:           [[VAL_12:%.*]] = constant 1024 : index
 // CHECK:           [[VAL_13:%.*]] = cmpi eq, [[VAL_10]], [[VAL_12]] : index
 // CHECK:           [[VAL_14:%.*]] = constant 64 : index
 // CHECK:           [[VAL_15:%.*]] = cmpi eq, [[VAL_11]], [[VAL_14]] : index
 // CHECK:           [[VAL_16:%.*]] = and [[VAL_13]], [[VAL_15]] : i1
 // CHECK:           scf.if [[VAL_16]] {
 // CHECK:             scf.parallel ([[VAL_17:%.*]], [[VAL_18:%.*]]) = ([[VAL_6]], [[VAL_6]]) to ([[VAL_12]], [[VAL_14]]) step ([[VAL_7]], [[VAL_7]]) {
-// CHECK:               store
+// CHECK:               memref.store
 // CHECK:             }
 // CHECK:           } else {
 // CHECK:             scf.parallel ([[VAL_22:%.*]], [[VAL_23:%.*]]) = ([[VAL_6]], [[VAL_6]]) to ([[VAL_10]], [[VAL_11]]) step ([[VAL_7]], [[VAL_7]]) {
-// CHECK:               store
+// CHECK:               memref.store
 // CHECK:             }
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }

mlir/test/Dialect/SCF/parallel-loop-tiling.mlir

 // RUN: mlir-opt %s -pass-pipeline='func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s
 
 func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
                     %arg3 : index, %arg4 : index, %arg5 : index,
         %A: memref<?x?xf32>, %B: memref<?x?xf32>,
                     %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) {
     %B_elem = load %B[%i0, %i1] : memref<?x?xf32>
     %C_elem = load %C[%i0, %i1] : memref<?x?xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
-    store %sum_elem, %result[%i0, %i1] : memref<?x?xf32>
+    memref.store %sum_elem, %result[%i0, %i1] : memref<?x?xf32>
   }
   return
 }
 
 // CHECK:       #map = affine_map<(d0, d1, d2) -> (d0, d1 - d2)>
 // CHECK-LABEL:   func @parallel_loop(
 // CHECK-SAME:                        [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index, [[ARG5:%.*]]: index, [[ARG6:%.*]]: index, [[ARG7:%.*]]: memref<?x?xf32>, [[ARG8:%.*]]: memref<?x?xf32>, [[ARG9:%.*]]: memref<?x?xf32>, [[ARG10:%.*]]: memref<?x?xf32>) {
 // CHECK:           [[C0:%.*]] = constant 0 : index
 // CHECK:           [[C1:%.*]] = constant 1 : index
 // CHECK:           [[C4:%.*]] = constant 4 : index
 // CHECK:           [[V1:%.*]] = muli [[ARG5]], [[C1]] : index
 // CHECK:           [[V2:%.*]] = muli [[ARG6]], [[C4]] : index
 // CHECK:           scf.parallel ([[V3:%.*]], [[V4:%.*]]) = ([[ARG1]], [[ARG2]]) to ([[ARG3]], [[ARG4]]) step ([[V1]], [[V2]]) {
 // CHECK:             [[V5:%.*]] = affine.min #map([[V1]], [[ARG3]], [[V3]])
 // CHECK:             [[V6:%.*]] = affine.min #map([[V2]], [[ARG4]], [[V4]])
 // CHECK:             scf.parallel ([[V7:%.*]], [[V8:%.*]]) = ([[C0]], [[C0]]) to ([[V5]], [[V6]]) step ([[ARG5]], [[ARG6]]) {
 // CHECK:               [[V9:%.*]] = addi [[V7]], [[V3]] : index
 // CHECK:               [[V10:%.*]] = addi [[V8]], [[V4]] : index
 // CHECK:               [[V11:%.*]] = load [[ARG8]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:               [[V12:%.*]] = load [[ARG9]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:               [[V13:%.*]] = addf [[V11]], [[V12]] : f32
-// CHECK:               store [[V13]], [[ARG10]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
+// CHECK:               memref.store [[V13]], [[ARG10]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:             }
 // CHECK:           }
 // CHECK:           return
 
 // -----
 
 func @static_loop_with_step() {
   %c0 = constant 0 : index

mlir/test/Dialect/Standard/canonicalize.mlir

 }
 
 // Test case: Folding of dim(memref_reshape %v %shp, %idx) -> load %shp[%idx]
 // CHECK-LABEL: func @dim_of_memref_reshape(
 //  CHECK-SAME:     %[[MEM:[0-9a-z]+]]: memref<*xf32>,
 //  CHECK-SAME:     %[[SHP:[0-9a-z]+]]: memref<?xindex>
 //  CHECK-NEXT:   %[[IDX:.*]] = constant 3
 //  CHECK-NEXT:   %[[DIM:.*]] = load %[[SHP]][%[[IDX]]]
-//  CHECK-NEXT:   store
+//  CHECK-NEXT:   memref.store
 //   CHECK-NOT:   dim
 //       CHECK:   return %[[DIM]] : index
 func @dim_of_memref_reshape(%arg0: memref<*xf32>, %arg1: memref<?xindex>)
     -> index {
   %c3 = constant 3 : index
   %0 = memref_reshape %arg0(%arg1)
       : (memref<*xf32>, memref<?xindex>) -> memref<*xf32>
   // Update the shape to test that he load ends up in the right place.
-  store %c3, %arg1[%c3] : memref<?xindex>
+  memref.store %c3, %arg1[%c3] : memref<?xindex>
   %1 = dim %0, %c3 : memref<*xf32>
   return %1 : index
 }
 
 // Test case: Folding dim(tensor.cast %0, %idx) -> dim %0, %idx
 // CHECK-LABEL: func @fold_dim_of_tensor.cast
 //  CHECK-SAME:   %[[ARG0:.[a-z0-9A-Z_]+]]: tensor<4x?xf32>
 //   CHECK-DAG:   %[[C1:.+]] = constant 1 : index
 //   CHECK-DAG:   %[[C4:.+]] = constant 4 : index
 //       CHECK:   %[[T0:.+]] = dim %[[ARG0]], %[[C1]]
 //  CHECK-NEXT:   return %[[C4]], %[[T0]]
 func @fold_dim_of_tensor.cast(%arg0 : tensor<4x?xf32>) -> (index, index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %0 = tensor.cast %arg0 : tensor<4x?xf32> to tensor<?x?xf32>
   %1 = dim %0, %c0 : tensor<?x?xf32>
   %2 = dim %0, %c1 : tensor<?x?xf32>
   return %1, %2: index, index
 }
 
 // CHECK-LABEL: func @tensor_cast_to_memref
 //  CHECK-SAME:   %[[ARG0:.+]]: tensor<4x6x16x32xi8>
 //       CHECK:   %[[M:.+]] = tensor_to_memref %[[ARG0]] : memref<4x6x16x32xi8>
-//       CHECK:   %[[M1:.+]] = memref_cast %[[M]] : memref<4x6x16x32xi8> to memref<?x?x16x32xi8>
+//       CHECK:   %[[M1:.+]] = memref.cast %[[M]] : memref<4x6x16x32xi8> to memref<?x?x16x32xi8>
 //       CHECK:   return %[[M1]] : memref<?x?x16x32xi8>
 func @tensor_cast_to_memref(%arg0 : tensor<4x6x16x32xi8>) ->
   memref<?x?x16x32xi8> {
   %0 = tensor.cast %arg0 : tensor<4x6x16x32xi8> to tensor<?x?x16x32xi8>
   %1 = tensor_to_memref %0 : memref<?x?x16x32xi8>
   return %1 : memref<?x?x16x32xi8>
 }
 
 // CHECK-LABEL: func @subview_of_memcast
 //  CHECK-SAME:   %[[ARG0:.[a-z0-9A-Z_]+]]: memref<4x6x16x32xi8>
 //       CHECK:   %[[S:.+]] = subview %arg0[0, 1, 0, 0] [1, 1, 16, 32] [1, 1, 1, 1] : memref<4x6x16x32xi8> to memref<16x32xi8, #{{.*}}>
-//       CHECK:   %[[M:.+]] = memref_cast %[[S]] : memref<16x32xi8, #{{.*}}> to memref<16x32xi8, #{{.*}}>
+//       CHECK:   %[[M:.+]] = memref.cast %[[S]] : memref<16x32xi8, #{{.*}}> to memref<16x32xi8, #{{.*}}>
 //       CHECK:   return %[[M]] : memref<16x32xi8, #{{.*}}>
 func @subview_of_memcast(%arg : memref<4x6x16x32xi8>) ->
   memref<16x32xi8, affine_map<(d0, d1)[s0] -> (d0 * 32 + d1 + s0)>>{
-  %0 = memref_cast %arg : memref<4x6x16x32xi8> to memref<?x?x16x32xi8>
+  %0 = memref.cast %arg : memref<4x6x16x32xi8> to memref<?x?x16x32xi8>
   %1 = subview %0[0, 1, 0, 0] [1, 1, 16, 32] [1, 1, 1, 1] :
     memref<?x?x16x32xi8> to
     memref<16x32xi8, affine_map<(d0, d1)[s0] -> (d0 * 32 + d1 + s0)>>
   return %1 : memref<16x32xi8, affine_map<(d0, d1)[s0] -> (d0 * 32 + d1 + s0)>>
 }

mlir/test/Dialect/Standard/invalid.mlir

func @test_index_cast_tensor_error(%arg0 : tensor<index>) -> i64 {
   %0 = index_cast %arg0 : tensor<index> to i64
   return %0 : i64
 }
 
 // -----
 
 func @transpose_not_permutation(%v : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+1 {{expected a permutation map}}
-  transpose %v (i, j) -> (i, i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
+  memref.transpose %v (i, j) -> (i, i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
 func @transpose_bad_rank(%v : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+1 {{expected a permutation map of same rank as the input}}
-  transpose %v (i) -> (i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
+  memref.transpose %v (i) -> (i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
 func @transpose_wrong_type(%v : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+1 {{output type 'memref<?x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>>' does not match transposed input type 'memref<?x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>>'}}
-  transpose %v (i, j) -> (j, i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
+  memref.transpose %v (i, j) -> (j, i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>> to memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
 func @memref_reinterpret_cast_too_many_offsets(%in: memref<?xf32>) {
   // expected-error @+1 {{expected <= 1 offset values}}
   %out = memref_reinterpret_cast %in to
            offset: [0, 0], sizes: [10, 10], strides: [10, 1]
func @memref_reshape_result_affine_map_is_not_identity(
   // expected-error @+1 {{result memref type should have identity affine map}}
   memref_reshape %buf(%shape)
     : (memref<4x4xf32>, memref<1xi32>) -> memref<8xf32, offset: 0, strides: [2]>
 }
 
 // -----
 
 // expected-error @+1 {{type should be static shaped memref}}
-global_memref @foo : i32
+memref.global @foo : i32
 
 // -----
 
 // expected-error @+1 {{type should be static shaped memref}}
-global_memref @foo : i32 = 5
+memref.global @foo : i32 = 5
 
 // -----
 
 // expected-error @+1 {{type should be static shaped memref}}
-global_memref @foo : memref<*xf32>
+memref.global @foo : memref<*xf32>
 
 // -----
 
 // expected-error @+1 {{type should be static shaped memref}}
-global_memref @foo : memref<?x?xf32>
+memref.global @foo : memref<?x?xf32>
 
 // -----
 
 // expected-error @+1 {{initial value should be a unit or elements attribute}}
-global_memref @foo : memref<2x2xf32>  = "foo"
+memref.global @foo : memref<2x2xf32>  = "foo"
 
 // -----
 
 // expected-error @+1 {{inferred shape of elements literal ([2]) does not match type ([2, 2])}}
-global_memref @foo : memref<2x2xf32> = dense<[0.0, 1.0]>
+memref.global @foo : memref<2x2xf32> = dense<[0.0, 1.0]>
 
 // -----
 
 // expected-error @+1 {{expected valid '@'-identifier for symbol name}}
-global_memref "private" "public" @foo : memref<2x2xf32>  = "foo"
+memref.global "private" "public" @foo : memref<2x2xf32>  = "foo"
 
 // -----
 
 // expected-error @+1 {{expected valid '@'-identifier for symbol name}}
-global_memref constant external @foo : memref<2x2xf32>  = "foo"
+memref.global constant external @foo : memref<2x2xf32>  = "foo"
 
 // -----
 
 // constant qualifier must be after visibility.
 // expected-error @+1 {{expected valid '@'-identifier for symbol name}}
-global_memref constant "private" @foo : memref<2x2xf32>  = "foo"
+memref.global constant "private" @foo : memref<2x2xf32>  = "foo"
 
 
 // -----
 
 // expected-error @+1 {{op visibility expected to be one of ["public", "private", "nested"], but got "priate"}}
-global_memref "priate" constant @memref5 : memref<2xf32>  = uninitialized
+memref.global "priate" constant @memref5 : memref<2xf32>  = uninitialized
 
 // -----
 
 func @nonexistent_global_memref() {
   // expected-error @+1 {{'gv' does not reference a valid global memref}}
-  %0 = get_global_memref @gv : memref<3xf32>
+  %0 = memref.get_global @gv : memref<3xf32>
   return
 }
 
 // -----
 
 func @foo()
 
 func @nonexistent_global_memref() {
   // expected-error @+1 {{'foo' does not reference a valid global memref}}
-  %0 = get_global_memref @foo : memref<3xf32>
+  %0 = memref.get_global @foo : memref<3xf32>
   return
 }
 
 // -----
 
-global_memref @gv : memref<3xi32>
+memref.global @gv : memref<3xi32>
 
 func @mismatched_types() {
   // expected-error @+1 {{result type 'memref<3xf32>' does not match type 'memref<3xi32>' of the global memref @gv}}
-  %0 = get_global_memref @gv : memref<3xf32>
+  %0 = memref.get_global @gv : memref<3xf32>
   return
 }
 
 // -----
 
 func @non_signless_constant() {
   // expected-error @+1 {{requires integer result types to be signless}}
   %0 = constant 0 : ui32

mlir/test/Dialect/Standard/ops.mlir

%dyn_vec = memref_reshape %unranked(%shape1)
                : (memref<*xf32>, memref<1xi32>) -> memref<?xf32>
   %dyn_mat = memref_reshape %dyn_vec(%shape2)
                : (memref<?xf32>, memref<2xi32>) -> memref<?x?xf32>
   %new_unranked = memref_reshape %dyn_mat(%shape3)
                : (memref<?x?xf32>, memref<?xi32>) -> memref<*xf32>
   return %new_unranked : memref<*xf32>
 }
 
-// CHECK-LABEL: global_memref @memref0 : memref<2xf32>
-global_memref @memref0 : memref<2xf32>
+// CHECK-LABEL: memref.global @memref0 : memref<2xf32>
+memref.global @memref0 : memref<2xf32>
 
-// CHECK-LABEL: global_memref constant @memref1 : memref<2xf32> = dense<[0.000000e+00, 1.000000e+00]>
-global_memref constant @memref1 : memref<2xf32> = dense<[0.0, 1.0]>
+// CHECK-LABEL: memref.global constant @memref1 : memref<2xf32> = dense<[0.000000e+00, 1.000000e+00]>
+memref.global constant @memref1 : memref<2xf32> = dense<[0.0, 1.0]>
 
-// CHECK-LABEL: global_memref @memref2 : memref<2xf32> = uninitialized
-global_memref @memref2 : memref<2xf32>  = uninitialized
+// CHECK-LABEL: memref.global @memref2 : memref<2xf32> = uninitialized
+memref.global @memref2 : memref<2xf32>  = uninitialized
 
-// CHECK-LABEL: global_memref "private" @memref3 : memref<2xf32> = uninitialized
-global_memref "private" @memref3 : memref<2xf32>  = uninitialized
+// CHECK-LABEL: memref.global "private" @memref3 : memref<2xf32> = uninitialized
+memref.global "private" @memref3 : memref<2xf32>  = uninitialized
 
-// CHECK-LABEL: global_memref "private" constant @memref4 : memref<2xf32> = uninitialized
-global_memref "private" constant @memref4 : memref<2xf32>  = uninitialized
+// CHECK-LABEL: memref.global "private" constant @memref4 : memref<2xf32> = uninitialized
+memref.global "private" constant @memref4 : memref<2xf32>  = uninitialized
 
 // CHECK-LABEL: func @write_global_memref
 func @write_global_memref() {
-  %0 = get_global_memref @memref0 : memref<2xf32>
+  %0 = memref.get_global @memref0 : memref<2xf32>
   %1 = constant dense<[1.0, 2.0]> : tensor<2xf32>
   tensor_store %1, %0 : memref<2xf32>
   return
 }
 
 // CHECK-LABEL: func @read_global_memref
 func @read_global_memref() {
-  %0 = get_global_memref @memref0 : memref<2xf32>
+  %0 = memref.get_global @memref0 : memref<2xf32>
   %1 = tensor_load %0 : memref<2xf32>
   return
 }

mlir/test/Dialect/Tensor/bufferize.mlir

 // RUN: mlir-opt %s -tensor-bufferize | FileCheck %s
 
 // CHECK-LABEL:   func @tensor.cast(
 // CHECK-SAME:                      %[[TENSOR:.*]]: tensor<?xindex>) -> tensor<2xindex> {
 // CHECK:           %[[MEMREF:.*]] = tensor_to_memref %[[TENSOR]]
-// CHECK:           %[[CASTED:.*]] = memref_cast %[[MEMREF]] : memref<?xindex> to memref<2xindex>
+// CHECK:           %[[CASTED:.*]] = memref.cast %[[MEMREF]] : memref<?xindex> to memref<2xindex>
 // CHECK:           %[[RET:.*]] = tensor_load %[[CASTED]]
 // CHECK:           return %[[RET]] : tensor<2xindex>
 func @tensor.cast(%arg0: tensor<?xindex>) -> tensor<2xindex> {
   %0 = tensor.cast %arg0 : tensor<?xindex> to tensor<2xindex>
   return %0 : tensor<2xindex>
 }
 
 // CHECK-LABEL:   func @tensor.cast_from_unranked(
 // CHECK-SAME:                                    %[[TENSOR:.*]]: tensor<*xf32>) -> tensor<2xf32> {
 // CHECK:           %[[MEMREF:.*]] = tensor_to_memref %[[TENSOR]] : memref<*xf32>
-// CHECK:           %[[CASTED_MEMREF:.*]] = memref_cast %[[MEMREF]] : memref<*xf32> to memref<2xf32>
+// CHECK:           %[[CASTED_MEMREF:.*]] = memref.cast %[[MEMREF]] : memref<*xf32> to memref<2xf32>
 // CHECK:           %[[RET:.*]] = tensor_load %[[CASTED_MEMREF]] : memref<2xf32>
 // CHECK:           return %[[RET]] : tensor<2xf32>
 func @tensor.cast_from_unranked(%arg0: tensor<*xf32>) -> tensor<2xf32> {
   %0 = tensor.cast %arg0 : tensor<*xf32> to tensor<2xf32>
   return %0 : tensor<2xf32>
 }
 
 // CHECK-LABEL:   func @tensor.cast_to_unranked(
 // CHECK-SAME:                                  %[[TENSOR:.*]]: tensor<2xf32>) -> tensor<*xf32> {
 // CHECK:           %[[MEMREF:.*]] = tensor_to_memref %[[TENSOR]] : memref<2xf32>
-// CHECK:           %[[CASTED_MEMREF:.*]] = memref_cast %[[MEMREF]] : memref<2xf32> to memref<*xf32>
+// CHECK:           %[[CASTED_MEMREF:.*]] = memref.cast %[[MEMREF]] : memref<2xf32> to memref<*xf32>
 // CHECK:           %[[RET:.*]] = tensor_load %[[CASTED_MEMREF]] : memref<*xf32>
 // CHECK:           return %[[RET]] : tensor<*xf32>
 func @tensor.cast_to_unranked(%arg0: tensor<2xf32>) -> tensor<*xf32> {
   %0 = tensor.cast %arg0 : tensor<2xf32> to tensor<*xf32>
   return %0 : tensor<*xf32>
 }
 
 // CHECK-LABEL:   func @tensor.extract(
 // CHECK-SAME:                  %[[TENSOR:.*]]: tensor<?xf32>,
 // CHECK-SAME:                  %[[IDX:.*]]: index) -> f32 {
 // CHECK:           %[[MEMREF:.*]] = tensor_to_memref %[[TENSOR]] : memref<?xf32>
 // CHECK:           %[[RET:.*]] = load %[[MEMREF]][%[[IDX]]] : memref<?xf32>
 // CHECK:           return %[[RET]] : f32
 // CHECK:         }
 func @tensor.extract(%arg0: tensor<?xf32>, %arg1: index) -> f32 {
   %0 = tensor.extract %arg0[%arg1] : tensor<?xf32>
   return %0 : f32
 }
 
 // CHECK-LABEL:   func @tensor.from_elements(
 // CHECK-SAME:                               %[[ELEM0:.*]]: index,
 // CHECK-SAME:                               %[[ELEM1:.*]]: index) -> tensor<2xindex> {
-// CHECK:           %[[MEMREF:.*]] = alloc()
+// CHECK:           %[[MEMREF:.*]] = memref.alloc()
 // CHECK:           %[[C0:.*]] = constant 0 : index
 // CHECK:           store %[[ELEM0]], %[[MEMREF]][%[[C0]]]
 // CHECK:           %[[C1:.*]] = constant 1 : index
 // CHECK:           store %[[ELEM1]], %[[MEMREF]][%[[C1]]]
 // CHECK:           %[[RET:.*]] = tensor_load %[[MEMREF]]
 // CHECK:           return %[[RET]] : tensor<2xindex>
 func @tensor.from_elements(%arg0: index, %arg1: index) -> tensor<2xindex> {
   %0 = tensor.from_elements %arg0, %arg1 : tensor<2xindex>
   return %0 : tensor<2xindex>
 }
 
 // CHECK-LABEL:   func @tensor.generate(
 // CHECK-SAME:                                       %[[ARG:.*]]: tensor<*xf32>,
 // CHECK-SAME:                                       %[[DYNAMIC_EXTENT:.*]]: index) -> tensor<?xindex> {
-// CHECK:           %[[MEMREF:.*]] = alloc(%[[DYNAMIC_EXTENT]]) : memref<?xindex>
+// CHECK:           %[[MEMREF:.*]] = memref.alloc(%[[DYNAMIC_EXTENT]]) : memref<?xindex>
 // CHECK:           %[[C0:.*]] = constant 0 : index
 // CHECK:           %[[C1:.*]] = constant 1 : index
 // CHECK:           scf.parallel (%[[I:.*]]) = (%[[C0]]) to (%[[DYNAMIC_EXTENT]]) step (%[[C1]]) {
 // CHECK:             %[[ELEM:.*]] = dim %[[ARG]], %[[I]] : tensor<*xf32>
 // CHECK:             store %[[ELEM]], %[[MEMREF]][%[[I]]] : memref<?xindex>
 // CHECK:             scf.yield
 // CHECK:           }
 // CHECK:           %[[RET:.*]] = tensor_load %[[MEMREF]] : memref<?xindex>
 // CHECK:           return %[[RET]] : tensor<?xindex>
 // CHECK:         }
 func @tensor.generate(%arg: tensor<*xf32>, %dynamic_extent: index) -> tensor<?xindex> {
   %result = tensor.generate %dynamic_extent {
   ^bb0(%i : index):
     %elem = dim %arg, %i : tensor<*xf32>
     tensor.yield %elem : index
   } : tensor<?xindex>
   return %result : tensor<?xindex>
 }
 
 // Additional test that checks the logic for intermixed static and dynamic
 // extents.
 //
 // CHECK-LABEL:   func @tensor.generate_static_and_dynamic(
 // CHECK-SAME:                                                          %[[DYNAMIC_EXTENT:.*]]: index) -> tensor<16x?xindex> {
-// CHECK:           %[[MEMREF:.*]] = alloc(%[[DYNAMIC_EXTENT]]) : memref<16x?xindex>
+// CHECK:           %[[MEMREF:.*]] = memref.alloc(%[[DYNAMIC_EXTENT]]) : memref<16x?xindex>
 // CHECK:           %[[C0:.*]] = constant 0 : index
 // CHECK:           %[[C1:.*]] = constant 1 : index
 // CHECK:           %[[C16:.*]] = constant 16 : index
 // CHECK:           scf.parallel (%[[I:.*]], %[[J:.*]]) = (%[[C0]], %[[C0]]) to (%[[C16]], %[[DYNAMIC_EXTENT]]) step (%[[C1]], %[[C1]]) {
 // CHECK:             %[[VAL_7:.*]] = addi %[[I]], %[[J]] : index
 // CHECK:             store %[[VAL_7]], %[[MEMREF]][%[[I]], %[[J]]] : memref<16x?xindex>
 // CHECK:             scf.yield
 // CHECK:           }

mlir/test/Dialect/Tensor/canonicalize.mlir

 }
 
 // -----
 
 // CHECK-LABEL: func @extract_from_tensor.generate_sideeffects
 // CHECK-SAME: %[[IDX:.*]]: index
 func @extract_from_tensor.generate_sideeffects(%idx: index, %tensor: tensor<*xf32>) -> index {
   %size = rank %tensor : tensor<*xf32>
-  %mem = alloc(%size) : memref<?xindex>
+  %mem = memref.alloc(%size) : memref<?xindex>
   // CHECK: %[[DTENSOR:.*]] = tensor.generate
   %0 = tensor.generate %size {
     ^bb0(%arg0: index):
     %1 = dim %tensor, %arg0 : tensor<*xf32>
-    store %1, %mem[%arg0] : memref<?xindex>
+    memref.store %1, %mem[%arg0] : memref<?xindex>
     tensor.yield %1 : index
   } : tensor<?xindex>
   // CHECK: %[[RES:.*]] = tensor.extract %[[DTENSOR]][%[[IDX]]]
   %1 = tensor.extract %0[%idx] : tensor<?xindex>
   // CHECK-NEXT: return %[[RES]]
   return %1 : index
 }
 

mlir/test/Dialect/Vector/canonicalize.mlir

 }
 
 // -----
 
 // CHECK-LABEL: cast_transfers
 func @cast_transfers(%A: memref<4x8xf32>) -> (vector<4x8xf32>) {
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
-  %0 = memref_cast %A : memref<4x8xf32> to memref<?x?xf32>
+  %0 = memref.cast %A : memref<4x8xf32> to memref<?x?xf32>
 
   // CHECK: vector.transfer_read %{{.*}} {masked = [false, false]} : memref<4x8xf32>, vector<4x8xf32>
   %1 = vector.transfer_read %0[%c0, %c0], %f0 : memref<?x?xf32>, vector<4x8xf32>
 
   // CHECK: vector.transfer_write %{{.*}} {masked = [false, false]} : vector<4x8xf32>, memref<4x8xf32>
   vector.transfer_write %1, %0[%c0, %c0] : vector<4x8xf32>, memref<?x?xf32>
   return %1 : vector<4x8xf32>
 }

mlir/test/Dialect/Vector/vector-contract-matvec-transforms.mlir

 // CHECK: %[[T2:.*]] = load %[[C]][] : memref<vector<2xf32>>
 // CHECK: %[[T3:.*]] = vector.transpose %[[T0]], [1, 0] : vector<2x2xf32> to vector<2x2xf32>
 // CHECK: %[[T4:.*]] = vector.extract %[[T3]][0] : vector<2x2xf32>
 // CHECK: %[[T5:.*]] = vector.extract %[[T1]][0] : vector<2xf32>
 // CHECK: %[[T6:.*]] = vector.outerproduct %[[T4]], %[[T5]], %[[T2]] {kind = #vector.kind<add>} : vector<2xf32>, f32
 // CHECK: %[[T7:.*]] = vector.extract %[[T3]][1] : vector<2x2xf32>
 // CHECK: %[[T8:.*]] = vector.extract %[[T1]][1] : vector<2xf32>
 // CHECK: %[[T9:.*]] = vector.outerproduct %[[T7]], %[[T8]], %[[T6]] {kind = #vector.kind<add>} : vector<2xf32>, f32
-// CHECK: store %[[T9]], %[[C]][] : memref<vector<2xf32>>
+// CHECK: memref.store %[[T9]], %[[C]][] : memref<vector<2xf32>>
 // CHECK: return
 func @matvec2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
                                                 %arg2: memref<vector<2xf32>>) {
   %A = load %arg0[] : memref<vector<2x2xf32>>
   %x = load %arg1[] : memref<vector<2xf32>>
   %b = load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #matvec_trait %A, %x, %b : vector<2x2xf32>, vector<2xf32> into vector<2xf32>
-  store %0, %arg2[] : memref<vector<2xf32>>
+  memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }
 
 // CHECK-LABEL: func @matvecmax2x2
 // CHECK-SAME: %[[A:.*0]]: memref<vector<2x2xf32>>
 // CHECK-SAME: %[[B:.*1]]: memref<vector<2xf32>>
 // CHECK-SAME: %[[C:.*2]]: memref<vector<2xf32>>
 // CHECK: %[[T0:.*]] = load %[[A]][] : memref<vector<2x2xf32>>
 // CHECK: %[[T1:.*]] = load %[[B]][] : memref<vector<2xf32>>
 // CHECK: %[[T2:.*]] = load %[[C]][] : memref<vector<2xf32>>
 // CHECK: %[[T3:.*]] = vector.transpose %[[T0]], [1, 0] : vector<2x2xf32> to vector<2x2xf32>
 // CHECK: %[[T4:.*]] = vector.extract %[[T3]][0] : vector<2x2xf32>
 // CHECK: %[[T5:.*]] = vector.extract %[[T1]][0] : vector<2xf32>
 // CHECK: %[[T6:.*]] = vector.outerproduct %[[T4]], %[[T5]], %[[T2]] {kind = #vector.kind<max>} : vector<2xf32>, f32
 // CHECK: %[[T7:.*]] = vector.extract %[[T3]][1] : vector<2x2xf32>
 // CHECK: %[[T8:.*]] = vector.extract %[[T1]][1] : vector<2xf32>
 // CHECK: %[[T9:.*]] = vector.outerproduct %[[T7]], %[[T8]], %[[T6]] {kind = #vector.kind<max>} : vector<2xf32>, f32
-// CHECK: store %[[T9]], %[[C]][] : memref<vector<2xf32>>
+// CHECK: memref.store %[[T9]], %[[C]][] : memref<vector<2xf32>>
 // CHECK: return
 func @matvecmax2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
                                                    %arg2: memref<vector<2xf32>>) {
   %A = load %arg0[] : memref<vector<2x2xf32>>
   %x = load %arg1[] : memref<vector<2xf32>>
   %b = load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #matvecmax_trait %A, %x, %b : vector<2x2xf32>, vector<2xf32> into vector<2xf32>
-  store %0, %arg2[] : memref<vector<2xf32>>
+  memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }
 
 // CHECK-LABEL: func @mattransvec2x2
 // CHECK-SAME: %[[A:.*0]]: memref<vector<2x2xf32>>
 // CHECK-SAME: %[[B:.*1]]: memref<vector<2xf32>>
 // CHECK-SAME: %[[C:.*2]]: memref<vector<2xf32>>
 // CHECK: %[[T0:.*]] = load %[[A]][] : memref<vector<2x2xf32>>
 // CHECK: %[[T1:.*]] = load %[[B]][] : memref<vector<2xf32>>
 // CHECK: %[[T2:.*]] = load %[[C]][] : memref<vector<2xf32>>
 // CHECK: %[[T3:.*]] = vector.extract %[[T0]][0] : vector<2x2xf32>
 // CHECK: %[[T4:.*]] = vector.extract %[[T1]][0] : vector<2xf32>
 // CHECK: %[[T5:.*]] = vector.outerproduct %[[T3]], %[[T4]], %[[T2]] {kind = #vector.kind<add>} : vector<2xf32>, f32
 // CHECK: %[[T6:.*]] = vector.extract %[[T0]][1] : vector<2x2xf32>
 // CHECK: %[[T7:.*]] = vector.extract %[[T1]][1] : vector<2xf32>
 // CHECK: %[[T8:.*]] = vector.outerproduct %[[T6]], %[[T7]], %[[T5]] {kind = #vector.kind<add>} : vector<2xf32>, f32
-// CHECK: store %[[T8]], %[[C]][] : memref<vector<2xf32>>
+// CHECK: memref.store %[[T8]], %[[C]][] : memref<vector<2xf32>>
 // CHECK: return
 func @mattransvec2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
                                                      %arg2: memref<vector<2xf32>>) {
   %A = load %arg0[] : memref<vector<2x2xf32>>
   %x = load %arg1[] : memref<vector<2xf32>>
   %b = load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #mattransvec_trait %A, %x, %b : vector<2x2xf32>, vector<2xf32> into vector<2xf32>
-  store %0, %arg2[] : memref<vector<2xf32>>
+  memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }
 
 // CHECK-LABEL: func @vecmat2x2
 // CHECK-SAME: %[[A:.*0]]: memref<vector<2x2xf32>>
 // CHECK-SAME: %[[B:.*1]]: memref<vector<2xf32>>
 // CHECK-SAME: %[[C:.*2]]: memref<vector<2xf32>>
 // CHECK: %[[T0:.*]] = load %[[A]][] : memref<vector<2x2xf32>>
 // CHECK: %[[T1:.*]] = load %[[B]][] : memref<vector<2xf32>>
 // CHECK: %[[T2:.*]] = load %[[C]][] : memref<vector<2xf32>>
 // CHECK: %[[T3:.*]] = vector.transpose %[[T0]], [1, 0] : vector<2x2xf32> to vector<2x2xf32>
 // CHECK: %[[T4:.*]] = vector.extract %[[T3]][0] : vector<2x2xf32>
 // CHECK: %[[T5:.*]] = vector.extract %[[T1]][0] : vector<2xf32>
 // CHECK: %[[T6:.*]] = vector.outerproduct %[[T4]], %[[T5]], %[[T2]] {kind = #vector.kind<add>} : vector<2xf32>, f32
 // CHECK: %[[T7:.*]] = vector.extract %[[T3]][1] : vector<2x2xf32>
 // CHECK: %[[T8:.*]] = vector.extract %[[T1]][1] : vector<2xf32>
 // CHECK: %[[T9:.*]] = vector.outerproduct %[[T7]], %[[T8]], %[[T6]] {kind = #vector.kind<add>} : vector<2xf32>, f32
-// CHECK: store %[[T9]], %[[C]][] : memref<vector<2xf32>>
+// CHECK: memref.store %[[T9]], %[[C]][] : memref<vector<2xf32>>
 // CHECK: return
 func @vecmat2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
                                                 %arg2: memref<vector<2xf32>>) {
   %A = load %arg0[] : memref<vector<2x2xf32>>
   %x = load %arg1[] : memref<vector<2xf32>>
   %b = load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #vecmat_trait %x, %A, %b : vector<2xf32>, vector<2x2xf32> into vector<2xf32>
-  store %0, %arg2[] : memref<vector<2xf32>>
+  memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }
 
 // CHECK-LABEL: func @vecmattrans2x2
 // CHECK-SAME: %[[A:.*0]]: memref<vector<2x2xf32>>
 // CHECK-SAME: %[[B:.*1]]: memref<vector<2xf32>>
 // CHECK-SAME: %[[C:.*2]]: memref<vector<2xf32>>
 // CHECK: %[[T0:.*]] = load %[[A]][] : memref<vector<2x2xf32>>
 // CHECK: %[[T1:.*]] = load %[[B]][] : memref<vector<2xf32>>
 // CHECK: %[[T2:.*]] = load %[[C]][] : memref<vector<2xf32>>
 // CHECK: %[[T3:.*]] = vector.extract %[[T0]][0] : vector<2x2xf32>
 // CHECK: %[[T4:.*]] = vector.extract %[[T1]][0] : vector<2xf32>
 // CHECK: %[[T5:.*]] = vector.outerproduct %[[T3]], %[[T4]], %[[T2]] {kind = #vector.kind<add>} : vector<2xf32>, f32
 // CHECK: %[[T6:.*]] = vector.extract %[[T0]][1] : vector<2x2xf32>
 // CHECK: %[[T7:.*]] = vector.extract %[[T1]][1] : vector<2xf32>
 // CHECK: %[[T8:.*]] = vector.outerproduct %[[T6]], %[[T7]], %[[T5]] {kind = #vector.kind<add>} : vector<2xf32>, f32
-// CHECK: store %[[T8]], %[[C]][] : memref<vector<2xf32>>
+// CHECK: memref.store %[[T8]], %[[C]][] : memref<vector<2xf32>>
 // CHECK: return
 func @vecmattrans2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
                                                      %arg2: memref<vector<2xf32>>) {
   %A = load %arg0[] : memref<vector<2x2xf32>>
   %x = load %arg1[] : memref<vector<2xf32>>
   %b = load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #vecmattrans_trait %x, %A, %b : vector<2xf32>, vector<2x2xf32> into vector<2xf32>
-  store %0, %arg2[] : memref<vector<2xf32>>
+  memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }

mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir

 func @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> {
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
 
   //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   //  CHECK-DAG: %[[c8:.*]] = constant 8 : index
   //  CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
-  //      CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
+  //      CHECK: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      CHECK: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
   // %j + 8 <= dim(%A, 1)
   //      CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      CHECK: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      CHECK: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32>, index, index) {
   //               inBounds, just yield %A
   //      CHECK:   scf.yield %[[A]], %[[i]], %[[j]] : memref<?x8xf32>, index, index
   //      CHECK: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
   //      CHECK:   %[[slow:.*]] = vector.transfer_read %[[A]][%[[i]], %[[j]]], %cst :
   // CHECK-SAME:     memref<?x8xf32>, vector<4x8xf32>
   //      CHECK:   %[[cast_alloc:.*]] = vector.type_cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<vector<4x8xf32>>
   //      CHECK:   store %[[slow]], %[[cast_alloc]][] : memref<vector<4x8xf32>>
-  //      CHECK:   %[[yielded:.*]] = memref_cast %[[alloc]] :
+  //      CHECK:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<?x8xf32>
   //      CHECK:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // CHECK-SAME:     memref<?x8xf32>, index, index
   //      CHECK: }
   //      CHECK: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]]
   // CHECK_SAME:   {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32>
 
   //  LINALG-DAG: %[[c0:.*]] = constant 0 : index
   //  LINALG-DAG: %[[c4:.*]] = constant 4 : index
   //  LINALG-DAG: %[[c8:.*]] = constant 8 : index
   //  LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
-  //      LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
+  //      LINALG: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      LINALG: %[[d0:.*]] = dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
   // %j + 8 <= dim(%A, 1)
   //      LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32>, index, index) {
   //               inBounds, just yield %A
   //      LINALG:   scf.yield %[[A]], %[[i]], %[[j]] : memref<?x8xf32>, index, index
   //      LINALG: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
   //      LINALG:   linalg.fill(%[[alloc]], %[[cst]]) : memref<4x8xf32>, f32
   //      LINALG:   %[[d0:.*]] = dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      LINALG:   %[[sv0:.*]] = affine.min #[[$bounds_map_4]](%[[d0]], %[[i]], %[[c4]])
   //      LINALG:   %[[sv1:.*]] = affine.min #[[$bounds_map_8]](%[[c8]], %[[j]], %[[c8]])
   //      LINALG:   %[[sv:.*]] = subview %[[A]][%[[i]], %[[j]]] [%[[sv0]], %[[sv1]]] [1, 1]
   // LINALG-SAME:     memref<?x8xf32> to memref<?x?xf32, #[[$map_2d_stride_8x1]]>
   //      LINALG:   linalg.copy(%[[sv]], %[[alloc]]) : memref<?x?xf32, #[[$map_2d_stride_8x1]]>, memref<4x8xf32>
-  //      LINALG:   %[[yielded:.*]] = memref_cast %[[alloc]] :
+  //      LINALG:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // LINALG-SAME:     memref<4x8xf32> to memref<?x8xf32>
   //      LINALG:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // LINALG-SAME:     memref<?x8xf32>, index, index
   //      LINALG: }
   //      LINALG: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]]
   // LINALG_SAME:   {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32>
   %1 = vector.transfer_read %A[%i, %j], %f0 : memref<?x8xf32>, vector<4x8xf32>
 
func @split_vector_transfer_read_strided_2d(
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
 
   //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   //  CHECK-DAG: %[[c7:.*]] = constant 7 : index
   //  CHECK-DAG: %[[c8:.*]] = constant 8 : index
   //  CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
-  //      CHECK: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
+  //      CHECK: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
   // %j + 8 <= dim(%A, 1)
   //      CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      CHECK: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      CHECK: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      CHECK: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index) {
   //               inBounds but not cast-compatible: yield a memref_casted form of %A
-  //      CHECK:   %[[casted:.*]] = memref_cast %arg0 :
+  //      CHECK:   %[[casted:.*]] = memref.cast %arg0 :
   // CHECK-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      CHECK:   scf.yield %[[casted]], %[[i]], %[[j]] :
   // CHECK-SAME:     memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index
   //      CHECK: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
   //      CHECK:   %[[slow:.*]] = vector.transfer_read %[[A]][%[[i]], %[[j]]], %cst :
   // CHECK-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32>
   //      CHECK:   %[[cast_alloc:.*]] = vector.type_cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<vector<4x8xf32>>
   //      CHECK:   store %[[slow]], %[[cast_alloc]][] :
   // CHECK-SAME:     memref<vector<4x8xf32>>
-  //      CHECK:   %[[yielded:.*]] = memref_cast %[[alloc]] :
+  //      CHECK:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      CHECK:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // CHECK-SAME:     memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index
   //      CHECK: }
   //      CHECK: %[[res:.*]] = vector.transfer_read {{.*}} {masked = [false, false]} :
   // CHECK-SAME:   memref<?x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32>
 
   //  LINALG-DAG: %[[c0:.*]] = constant 0 : index
   //  LINALG-DAG: %[[c4:.*]] = constant 4 : index
   //  LINALG-DAG: %[[c7:.*]] = constant 7 : index
   //  LINALG-DAG: %[[c8:.*]] = constant 8 : index
   //  LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
-  //      LINALG: %[[alloc:.*]] = alloca() {alignment = 32 : i64} : memref<4x8xf32>
+  //      LINALG: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
   // %j + 8 <= dim(%A, 1)
   //      LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index) {
   //               inBounds but not cast-compatible: yield a memref_casted form of %A
-  //      LINALG:   %[[casted:.*]] = memref_cast %arg0 :
+  //      LINALG:   %[[casted:.*]] = memref.cast %arg0 :
   // LINALG-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   scf.yield %[[casted]], %[[i]], %[[j]] :
   // LINALG-SAME:     memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index
   //      LINALG: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
   //      LINALG:   linalg.fill(%[[alloc]], %[[cst]]) : memref<4x8xf32>, f32
   //      LINALG:   %[[sv0:.*]] = affine.min #[[$bounds_map_4]](%[[c7]], %[[i]], %[[c4]])
   //      LINALG:   %[[sv1:.*]] = affine.min #[[$bounds_map_8]](%[[c8]], %[[j]], %[[c8]])
   //      LINALG:   %[[sv:.*]] = subview %[[A]][%[[i]], %[[j]]] [%[[sv0]], %[[sv1]]] [1, 1]
   // LINALG-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]> to memref<?x?xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   linalg.copy(%[[sv]], %[[alloc]]) : memref<?x?xf32, #[[$map_2d_stride_1]]>, memref<4x8xf32>
-  //      LINALG:   %[[yielded:.*]] = memref_cast %[[alloc]] :
+  //      LINALG:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // LINALG-SAME:     memref<4x8xf32> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // LINALG-SAME:     memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index
   //      LINALG: }
   //      LINALG: %[[res:.*]] = vector.transfer_read {{.*}} {masked = [false, false]} :
   // LINALG-SAME:   memref<?x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32>
   %1 = vector.transfer_read %A[%i, %j], %f0 :
     memref<7x8xf32, offset:?, strides:[?, 1]>, vector<4x8xf32>
 
   // CHECK: return %[[res]] : vector<4x8xf32>
   return %1 : vector<4x8xf32>
 }

mlir/test/Dialect/Vector/vector-transforms.mlir

 // TODO: Update test with VTR split transform.
 // CHECK-LABEL: func @vector_transfers
 // CHECK-COUNT-8: vector.transfer_read
 // CHECK-COUNT-4: addf
 // CHECK-COUNT-4: vector.transfer_write
 
 func @vector_transfers(%arg0: index, %arg1: index) {
   %cst = constant 0.000000e+00 : f32
-  %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %1 = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %2 = alloc(%arg0, %arg1) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %2 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   %cst_0 = constant 1.000000e+00 : f32
   %cst_1 = constant 2.000000e+00 : f32
   affine.for %arg2 = 0 to %arg0 step 4 {
     affine.for %arg3 = 0 to %arg1 step 4 {
       %4 = vector.transfer_read %0[%arg2, %arg3], %cst {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : memref<?x?xf32>, vector<4x4xf32>
       %5 = vector.transfer_read %1[%arg2, %arg3], %cst {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : memref<?x?xf32>, vector<4x4xf32>
       %6 = addf %4, %5 : vector<4x4xf32>
       vector.transfer_write %6, %2[%arg2, %arg3] {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : vector<4x4xf32>, memref<?x?xf32>

 // CHECK-NEXT: vector.transfer_write %[[VTR0]], %{{.*}}[%[[C0]], %[[C0]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
 // CHECK-NEXT: vector.transfer_write %[[VTR1]], %{{.*}}[%[[C0]], %[[C1]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
 
 func @vector_transfers_vector_element_type() {
   %c0 = constant 0 : index
   %cf0 = constant 0.000000e+00 : f32
   %vf0 = splat %cf0 : vector<2x4xf32>
 
-  %0 = alloc() : memref<6x2x1xvector<2x4xf32>>
+  %0 = memref.alloc() : memref<6x2x1xvector<2x4xf32>>
 
   %1 = vector.transfer_read %0[%c0, %c0, %c0], %vf0
       {permutation_map = affine_map<(d0, d1, d2) -> (d1, d2)>}
         : memref<6x2x1xvector<2x4xf32>>, vector<2x1x2x4xf32>
 
   %2 = vector.extract_slices %1, [1, 1, 2, 4], [1, 1, 1, 1]
     : vector<2x1x2x4xf32> into tuple<vector<1x1x2x4xf32>, vector<1x1x2x4xf32>>
   %3 = vector.tuple_get %2, 0 : tuple<vector<1x1x2x4xf32>, vector<1x1x2x4xf32>>

mlir/test/Examples/Toy/Ch5/affine-lowering.mlir

 
 // CHECK-LABEL: func @main()
 // CHECK:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // CHECK:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // CHECK:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // CHECK:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // CHECK:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // CHECK:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// CHECK:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_7:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_8:%.*]] = alloc() : memref<2x3xf64>
+// CHECK:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_7:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_8:%.*]] = memref.alloc() : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_0]], [[VAL_8]][0, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_1]], [[VAL_8]][0, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_2]], [[VAL_8]][0, 2] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_3]], [[VAL_8]][1, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_4]], [[VAL_8]][1, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_5]], [[VAL_8]][1, 2] : memref<2x3xf64>
 // CHECK:         affine.for [[VAL_9:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_10:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_11:%.*]] = affine.load [[VAL_8]]{{\[}}[[VAL_10]], [[VAL_9]]] : memref<2x3xf64>
 // CHECK:             affine.store [[VAL_11]], [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_10]]] : memref<3x2xf64>
 // CHECK:         affine.for [[VAL_12:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_13:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_14:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_15:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_16:%.*]] = mulf [[VAL_14]], [[VAL_15]] : f64
 // CHECK:             affine.store [[VAL_16]], [[VAL_6]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:         toy.print [[VAL_6]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_8]] : memref<2x3xf64>
-// CHECK:         dealloc [[VAL_7]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_6]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_8]] : memref<2x3xf64>
+// CHECK:         memref.dealloc [[VAL_7]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_6]] : memref<3x2xf64>
 
 // OPT-LABEL: func @main()
 // OPT:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // OPT:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // OPT:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // OPT:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // OPT:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // OPT:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// OPT:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// OPT:         [[VAL_7:%.*]] = alloc() : memref<2x3xf64>
+// OPT:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// OPT:         [[VAL_7:%.*]] = memref.alloc() : memref<2x3xf64>
 // OPT:         affine.store [[VAL_0]], [[VAL_7]][0, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_1]], [[VAL_7]][0, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_2]], [[VAL_7]][0, 2] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_3]], [[VAL_7]][1, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_4]], [[VAL_7]][1, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_5]], [[VAL_7]][1, 2] : memref<2x3xf64>
 // OPT:         affine.for [[VAL_8:%.*]] = 0 to 3 {
 // OPT:           affine.for [[VAL_9:%.*]] = 0 to 2 {
 // OPT:             [[VAL_10:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_8]]] : memref<2x3xf64>
 // OPT:             [[VAL_11:%.*]] = mulf [[VAL_10]], [[VAL_10]] : f64
 // OPT:             affine.store [[VAL_11]], [[VAL_6]]{{\[}}[[VAL_8]], [[VAL_9]]] : memref<3x2xf64>
 // OPT:         toy.print [[VAL_6]] : memref<3x2xf64>
-// OPT:         dealloc [[VAL_7]] : memref<2x3xf64>
-// OPT:         dealloc [[VAL_6]] : memref<3x2xf64>
+// OPT:         memref.dealloc [[VAL_7]] : memref<2x3xf64>
+// OPT:         memref.dealloc [[VAL_6]] : memref<3x2xf64>

mlir/test/Examples/Toy/Ch6/affine-lowering.mlir

 
 // CHECK-LABEL: func @main()
 // CHECK:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // CHECK:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // CHECK:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // CHECK:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // CHECK:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // CHECK:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// CHECK:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_7:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_8:%.*]] = alloc() : memref<2x3xf64>
+// CHECK:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_7:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_8:%.*]] = memref.alloc() : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_0]], [[VAL_8]][0, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_1]], [[VAL_8]][0, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_2]], [[VAL_8]][0, 2] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_3]], [[VAL_8]][1, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_4]], [[VAL_8]][1, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_5]], [[VAL_8]][1, 2] : memref<2x3xf64>
 // CHECK:         affine.for [[VAL_9:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_10:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_11:%.*]] = affine.load [[VAL_8]]{{\[}}[[VAL_10]], [[VAL_9]]] : memref<2x3xf64>
 // CHECK:             affine.store [[VAL_11]], [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_10]]] : memref<3x2xf64>
 // CHECK:         affine.for [[VAL_12:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_13:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_14:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_15:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_16:%.*]] = mulf [[VAL_14]], [[VAL_15]] : f64
 // CHECK:             affine.store [[VAL_16]], [[VAL_6]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:         toy.print [[VAL_6]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_8]] : memref<2x3xf64>
-// CHECK:         dealloc [[VAL_7]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_6]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_8]] : memref<2x3xf64>
+// CHECK:         memref.dealloc [[VAL_7]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_6]] : memref<3x2xf64>
 
 // OPT-LABEL: func @main()
 // OPT:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // OPT:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // OPT:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // OPT:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // OPT:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // OPT:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// OPT:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// OPT:         [[VAL_7:%.*]] = alloc() : memref<2x3xf64>
+// OPT:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// OPT:         [[VAL_7:%.*]] = memref.alloc() : memref<2x3xf64>
 // OPT:         affine.store [[VAL_0]], [[VAL_7]][0, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_1]], [[VAL_7]][0, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_2]], [[VAL_7]][0, 2] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_3]], [[VAL_7]][1, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_4]], [[VAL_7]][1, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_5]], [[VAL_7]][1, 2] : memref<2x3xf64>
 // OPT:         affine.for [[VAL_8:%.*]] = 0 to 3 {
 // OPT:           affine.for [[VAL_9:%.*]] = 0 to 2 {
 // OPT:             [[VAL_10:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_8]]] : memref<2x3xf64>
 // OPT:             [[VAL_11:%.*]] = mulf [[VAL_10]], [[VAL_10]] : f64
 // OPT:             affine.store [[VAL_11]], [[VAL_6]]{{\[}}[[VAL_8]], [[VAL_9]]] : memref<3x2xf64>
 // OPT:         toy.print [[VAL_6]] : memref<3x2xf64>
-// OPT:         dealloc [[VAL_7]] : memref<2x3xf64>
-// OPT:         dealloc [[VAL_6]] : memref<3x2xf64>
+// OPT:         memref.dealloc [[VAL_7]] : memref<2x3xf64>
+// OPT:         memref.dealloc [[VAL_6]] : memref<3x2xf64>

mlir/test/Examples/Toy/Ch7/affine-lowering.mlir

 
 // CHECK-LABEL: func @main()
 // CHECK:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // CHECK:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // CHECK:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // CHECK:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // CHECK:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // CHECK:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// CHECK:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_7:%.*]] = alloc() : memref<3x2xf64>
-// CHECK:         [[VAL_8:%.*]] = alloc() : memref<2x3xf64>
+// CHECK:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_7:%.*]] = memref.alloc() : memref<3x2xf64>
+// CHECK:         [[VAL_8:%.*]] = memref.alloc() : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_0]], [[VAL_8]][0, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_1]], [[VAL_8]][0, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_2]], [[VAL_8]][0, 2] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_3]], [[VAL_8]][1, 0] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_4]], [[VAL_8]][1, 1] : memref<2x3xf64>
 // CHECK:         affine.store [[VAL_5]], [[VAL_8]][1, 2] : memref<2x3xf64>
 // CHECK:         affine.for [[VAL_9:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_10:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_11:%.*]] = affine.load [[VAL_8]]{{\[}}[[VAL_10]], [[VAL_9]]] : memref<2x3xf64>
 // CHECK:             affine.store [[VAL_11]], [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_10]]] : memref<3x2xf64>
 // CHECK:         affine.for [[VAL_12:%.*]] = 0 to 3 {
 // CHECK:           affine.for [[VAL_13:%.*]] = 0 to 2 {
 // CHECK:             [[VAL_14:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_15:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:             [[VAL_16:%.*]] = mulf [[VAL_14]], [[VAL_15]] : f64
 // CHECK:             affine.store [[VAL_16]], [[VAL_6]]{{\[}}[[VAL_12]], [[VAL_13]]] : memref<3x2xf64>
 // CHECK:         toy.print [[VAL_6]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_8]] : memref<2x3xf64>
-// CHECK:         dealloc [[VAL_7]] : memref<3x2xf64>
-// CHECK:         dealloc [[VAL_6]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_8]] : memref<2x3xf64>
+// CHECK:         memref.dealloc [[VAL_7]] : memref<3x2xf64>
+// CHECK:         memref.dealloc [[VAL_6]] : memref<3x2xf64>
 
 // OPT-LABEL: func @main()
 // OPT:         [[VAL_0:%.*]] = constant 1.000000e+00 : f64
 // OPT:         [[VAL_1:%.*]] = constant 2.000000e+00 : f64
 // OPT:         [[VAL_2:%.*]] = constant 3.000000e+00 : f64
 // OPT:         [[VAL_3:%.*]] = constant 4.000000e+00 : f64
 // OPT:         [[VAL_4:%.*]] = constant 5.000000e+00 : f64
 // OPT:         [[VAL_5:%.*]] = constant 6.000000e+00 : f64
-// OPT:         [[VAL_6:%.*]] = alloc() : memref<3x2xf64>
-// OPT:         [[VAL_7:%.*]] = alloc() : memref<2x3xf64>
+// OPT:         [[VAL_6:%.*]] = memref.alloc() : memref<3x2xf64>
+// OPT:         [[VAL_7:%.*]] = memref.alloc() : memref<2x3xf64>
 // OPT:         affine.store [[VAL_0]], [[VAL_7]][0, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_1]], [[VAL_7]][0, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_2]], [[VAL_7]][0, 2] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_3]], [[VAL_7]][1, 0] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_4]], [[VAL_7]][1, 1] : memref<2x3xf64>
 // OPT:         affine.store [[VAL_5]], [[VAL_7]][1, 2] : memref<2x3xf64>
 // OPT:         affine.for [[VAL_8:%.*]] = 0 to 3 {
 // OPT:           affine.for [[VAL_9:%.*]] = 0 to 2 {
 // OPT:             [[VAL_10:%.*]] = affine.load [[VAL_7]]{{\[}}[[VAL_9]], [[VAL_8]]] : memref<2x3xf64>
 // OPT:             [[VAL_11:%.*]] = mulf [[VAL_10]], [[VAL_10]] : f64
 // OPT:             affine.store [[VAL_11]], [[VAL_6]]{{\[}}[[VAL_8]], [[VAL_9]]] : memref<3x2xf64>
 // OPT:         toy.print [[VAL_6]] : memref<3x2xf64>
-// OPT:         dealloc [[VAL_7]] : memref<2x3xf64>
-// OPT:         dealloc [[VAL_6]] : memref<3x2xf64>
+// OPT:         memref.dealloc [[VAL_7]] : memref<2x3xf64>
+// OPT:         memref.dealloc [[VAL_6]] : memref<3x2xf64>

mlir/test/IR/core-ops.mlir

 func @load_store_prefetch(memref<4x4xi32>, index) {
 ^bb0(%0: memref<4x4xi32>, %1: index):
   // CHECK: %0 = load %arg0[%arg1, %arg1] : memref<4x4xi32>
   %2 = "std.load"(%0, %1, %1) : (memref<4x4xi32>, index, index)->i32
 
   // CHECK: %{{.*}} = load %arg0[%arg1, %arg1] : memref<4x4xi32>
   %3 = load %0[%1, %1] : memref<4x4xi32>
 
-  // CHECK: prefetch %arg0[%arg1, %arg1], write, locality<1>, data : memref<4x4xi32>
-  prefetch %0[%1, %1], write, locality<1>, data : memref<4x4xi32>
+  // CHECK: memref.prefetch %arg0[%arg1, %arg1], write, locality<1>, data : memref<4x4xi32>
+  memref.prefetch %0[%1, %1], write, locality<1>, data : memref<4x4xi32>
 
-  // CHECK: prefetch %arg0[%arg1, %arg1], read, locality<3>, instr : memref<4x4xi32>
-  prefetch %0[%1, %1], read, locality<3>, instr : memref<4x4xi32>
+  // CHECK: memref.prefetch %arg0[%arg1, %arg1], read, locality<3>, instr : memref<4x4xi32>
+  memref.prefetch %0[%1, %1], read, locality<3>, instr : memref<4x4xi32>
 
   return
 }
 
 // Test with zero-dimensional operands using no index in load/store.
 // CHECK-LABEL: func @zero_dim_no_idx
 func @zero_dim_no_idx(%arg0 : memref<i32>, %arg1 : memref<i32>, %arg2 : memref<i32>) {
   %0 = std.load %arg0[] : memref<i32>
-  std.store %0, %arg1[] : memref<i32>
+  memref.store %0, %arg1[] : memref<i32>
   return
   // CHECK: %0 = load %{{.*}}[] : memref<i32>
-  // CHECK: store %{{.*}}, %{{.*}}[] : memref<i32>
+  // CHECK: memref.store %{{.*}}, %{{.*}}[] : memref<i32>
 }
 
 // CHECK-LABEL: func @return_op(%arg0: i32) -> i32 {
 func @return_op(%a : i32) -> i32 {
   // CHECK: return %arg0 : i32
   "std.return" (%a) : (i32)->()
 }
 
func @calls(%arg0: i32) {
   // CHECK: %4 = call_indirect %f_0(%arg0) : (i32) -> i32
   %3 = "std.call_indirect"(%f_0, %arg0) : ((i32) -> i32, i32) -> i32
 
   return
 }
 
 // CHECK-LABEL: func @memref_cast(%arg0
 func @memref_cast(%arg0: memref<4xf32>, %arg1 : memref<?xf32>, %arg2 : memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]>) {
-  // CHECK: %0 = memref_cast %arg0 : memref<4xf32> to memref<?xf32>
-  %0 = memref_cast %arg0 : memref<4xf32> to memref<?xf32>
+  // CHECK: %0 = memref.cast %arg0 : memref<4xf32> to memref<?xf32>
+  %0 = memref.cast %arg0 : memref<4xf32> to memref<?xf32>
 
-  // CHECK: %1 = memref_cast %arg1 : memref<?xf32> to memref<4xf32>
-  %1 = memref_cast %arg1 : memref<?xf32> to memref<4xf32>
+  // CHECK: %1 = memref.cast %arg1 : memref<?xf32> to memref<4xf32>
+  %1 = memref.cast %arg1 : memref<?xf32> to memref<4xf32>
 
-  // CHECK: {{%.*}} = memref_cast %arg2 : memref<64x16x4xf32, #[[$BASE_MAP0]]> to memref<64x16x4xf32, #[[$BASE_MAP3]]>
-  %2 = memref_cast %arg2 : memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]> to memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]>
+  // CHECK: {{%.*}} = memref.cast %arg2 : memref<64x16x4xf32, #[[$BASE_MAP0]]> to memref<64x16x4xf32, #[[$BASE_MAP3]]>
+  %2 = memref.cast %arg2 : memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]> to memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]>
 
-  // CHECK: {{%.*}} = memref_cast {{%.*}} : memref<64x16x4xf32, #[[$BASE_MAP3]]> to memref<64x16x4xf32, #[[$BASE_MAP0]]>
-  %3 = memref_cast %2 : memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]> to memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]>
+  // CHECK: {{%.*}} = memref.cast {{%.*}} : memref<64x16x4xf32, #[[$BASE_MAP3]]> to memref<64x16x4xf32, #[[$BASE_MAP0]]>
+  %3 = memref.cast %2 : memref<64x16x4xf32, offset: ?, strides: [?, ?, ?]> to memref<64x16x4xf32, offset: 0, strides: [64, 4, 1]>
 
-  // CHECK: memref_cast %{{.*}} : memref<4xf32> to memref<*xf32>
-  %4 = memref_cast %1 : memref<4xf32> to memref<*xf32>
+  // CHECK: memref.cast %{{.*}} : memref<4xf32> to memref<*xf32>
+  %4 = memref.cast %1 : memref<4xf32> to memref<*xf32>
 
-  // CHECK: memref_cast %{{.*}} : memref<*xf32> to memref<4xf32>
-  %5 = memref_cast %4 : memref<*xf32> to memref<4xf32>
+  // CHECK: memref.cast %{{.*}} : memref<*xf32> to memref<4xf32>
+  %5 = memref.cast %4 : memref<*xf32> to memref<4xf32>
   return
 }
 
 // Check that unranked memrefs with non-default memory space roundtrip
 // properly.
 // CHECK-LABEL: @unranked_memref_roundtrip(memref<*xf32, 4>)
 func private @unranked_memref_roundtrip(memref<*xf32, 4>)
 
 // CHECK-LABEL: func @memref_view(%arg0
 func @memref_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
   // Test two dynamic sizes and dynamic offset.
-  // CHECK: %{{.*}} = std.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
-  %1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
+  // CHECK: %{{.*}} = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
+  %1 = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
 
   // Test one dynamic size and dynamic offset.
-  // CHECK: %{{.*}} = std.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
-  %3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
+  // CHECK: %{{.*}} = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
+  %3 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
 
   // Test static sizes and static offset.
-  // CHECK: %{{.*}} = std.view %0[{{.*}}][] : memref<2048xi8> to memref<64x4xf32>
+  // CHECK: %{{.*}} = memref.view %0[{{.*}}][] : memref<2048xi8> to memref<64x4xf32>
   %c0 = constant 0: index
-  %5 = view %0[%c0][] : memref<2048xi8> to memref<64x4xf32>
+  %5 = memref.view %0[%c0][] : memref<2048xi8> to memref<64x4xf32>
   return
 }
 
 // CHECK-LABEL: func @memref_subview(%arg0
 func @memref_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
 
-  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
+  %0 = memref.alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
   // CHECK: subview %0[%c0, %c0, %c0] [%arg0, %arg1, %arg2] [%c1, %c1, %c1] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<?x?x?xf32, #[[$BASE_MAP3]]>
   %1 = subview %0[%c0, %c0, %c0][%arg0, %arg1, %arg2][%c1, %c1, %c1]
     : memref<8x16x4xf32, offset:0, strides: [64, 4, 1]> to
       memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
-  %2 = alloc()[%arg2] : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>>
+  %2 = memref.alloc()[%arg2] : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>>
   // CHECK: subview %2[%c1] [%arg0] [%c1] :
   // CHECK-SAME: memref<64xf32, #[[$BASE_MAP1]]>
   // CHECK-SAME: to memref<?xf32, #[[$SUBVIEW_MAP1]]>
   %3 = subview %2[%c1][%arg0][%c1]
     : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>> to
       memref<?xf32, affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>>
 
-  %4 = alloc() : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>>
+  %4 = memref.alloc() : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>>
   // CHECK: subview %4[%c0, %c1] [%arg0, %arg1] [%c1, %c0] :
   // CHECK-SAME: memref<64x22xf32, #[[$BASE_MAP2]]>
   // CHECK-SAME: to memref<?x?xf32, #[[$SUBVIEW_MAP2]]>
   %5 = subview %4[%c0, %c1][%arg0, %arg1][%c1, %c0]
     : memref<64x22xf32, offset:0, strides: [22, 1]> to
       memref<?x?xf32, offset:?, strides: [?, ?]>
 
   // CHECK: subview %0[0, 2, 0] [4, 4, 4] [1, 1, 1] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<4x4x4xf32, #[[$SUBVIEW_MAP3]]>
   %6 = subview %0[0, 2, 0][4, 4, 4][1, 1, 1]
     : memref<8x16x4xf32, offset:0, strides: [64, 4, 1]> to
       memref<4x4x4xf32, offset:8, strides: [64, 4, 1]>
 
-  %7 = alloc(%arg1, %arg2) : memref<?x?xf32>
+  %7 = memref.alloc(%arg1, %arg2) : memref<?x?xf32>
   // CHECK: subview {{%.*}}[0, 0] [4, 4] [1, 1] :
   // CHECK-SAME: memref<?x?xf32>
   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP4]]>
   %8 = subview %7[0, 0][4, 4][1, 1]
     : memref<?x?xf32> to memref<4x4xf32, offset: ?, strides:[?, 1]>
 
-  %9 = alloc() : memref<16x4xf32>
+  %9 = memref.alloc() : memref<16x4xf32>
   // CHECK: subview {{%.*}}[{{%.*}}, {{%.*}}] [4, 4] [{{%.*}}, {{%.*}}] :
   // CHECK-SAME: memref<16x4xf32>
   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP2]]
   %10 = subview %9[%arg1, %arg1][4, 4][%arg2, %arg2]
     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[?, ?]>
 
   // CHECK: subview {{%.*}}[{{%.*}}, {{%.*}}] [4, 4] [2, 2] :
   // CHECK-SAME: memref<16x4xf32>
   // CHECK-SAME: to memref<4x4xf32, #[[$SUBVIEW_MAP5]]
   %11 = subview %9[%arg1, %arg2][4, 4][2, 2]
     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[8, 2]>
 
-  %12 = alloc() : memref<1x9x1x4x1xf32, affine_map<(d0, d1, d2, d3, d4) -> (36 * d0 + 36 * d1 + 4 * d2 + 4 * d3 + d4)>>
+  %12 = memref.alloc() : memref<1x9x1x4x1xf32, affine_map<(d0, d1, d2, d3, d4) -> (36 * d0 + 36 * d1 + 4 * d2 + 4 * d3 + d4)>>
   // CHECK: subview %12[%arg1, %arg1, %arg1, %arg1, %arg1]
   // CHECK-SAME: [1, 9, 1, 4, 1] [%arg2, %arg2, %arg2, %arg2, %arg2] :
   // CHECK-SAME: memref<1x9x1x4x1xf32, #[[$SUBVIEW_MAP6]]> to memref<9x4xf32, #[[$SUBVIEW_MAP2]]>
   %13 = subview %12[%arg1, %arg1, %arg1, %arg1, %arg1][1, 9, 1, 4, 1][%arg2, %arg2, %arg2, %arg2, %arg2] : memref<1x9x1x4x1xf32, offset: 0, strides: [36, 36, 4, 4, 1]> to memref<9x4xf32, offset: ?, strides: [?, ?]>
   // CHECK: subview %12[%arg1, %arg1, %arg1, %arg1, %arg1]
   // CHECK-SAME: [1, 9, 1, 4, 1] [%arg2, %arg2, %arg2, %arg2, %arg2] :
   // CHECK-SAME: memref<1x9x1x4x1xf32, #[[$SUBVIEW_MAP6]]> to memref<1x9x4xf32, #[[$BASE_MAP3]]>
   %14 = subview %12[%arg1, %arg1, %arg1, %arg1, %arg1][1, 9, 1, 4, 1][%arg2, %arg2, %arg2, %arg2, %arg2] : memref<1x9x1x4x1xf32, offset: 0, strides: [36, 36, 4, 4, 1]> to memref<1x9x4xf32, offset: ?, strides: [?, ?, ?]>
 
-  %15 = alloc(%arg1, %arg2)[%c0, %c1, %arg1, %arg0, %arg0, %arg2, %arg2] : memref<1x?x5x1x?x1xf32, affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (s0 + s1 * d0 + s2 * d1 + s3 * d2 + s4 * d3 + s5 * d4 + s6 * d5)>>
+  %15 = memref.alloc(%arg1, %arg2)[%c0, %c1, %arg1, %arg0, %arg0, %arg2, %arg2] : memref<1x?x5x1x?x1xf32, affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5, s6] -> (s0 + s1 * d0 + s2 * d1 + s3 * d2 + s4 * d3 + s5 * d4 + s6 * d5)>>
   // CHECK: subview %15[0, 0, 0, 0, 0, 0] [1, %arg1, 5, 1, %arg2, 1] [1, 1, 1, 1, 1, 1]  :
   // CHECK-SAME: memref<1x?x5x1x?x1xf32,  #[[$SUBVIEW_MAP7]]> to memref<?x5x?xf32, #[[$BASE_MAP3]]>
   %16 = subview %15[0, 0, 0, 0, 0, 0][1, %arg1, 5, 1, %arg2, 1][1, 1, 1, 1, 1, 1] : memref<1x?x5x1x?x1xf32, offset: ?, strides: [?, ?, ?, ?, ?, ?]> to memref<?x5x?xf32, offset: ?, strides: [?, ?, ?]>
   // CHECK: subview %15[%arg1, %arg1, %arg1, %arg1, %arg1, %arg1] [1, %arg1, 5, 1, %arg2, 1] [1, 1, 1, 1, 1, 1]  :
   // CHECK-SAME: memref<1x?x5x1x?x1xf32, #[[$SUBVIEW_MAP7]]> to memref<?x5x?x1xf32, #[[$SUBVIEW_MAP8]]>
   %17 = subview %15[%arg1, %arg1, %arg1, %arg1, %arg1, %arg1][1, %arg1, 5, 1, %arg2, 1][1, 1, 1, 1, 1, 1] :  memref<1x?x5x1x?x1xf32, offset: ?, strides: [?, ?, ?, ?, ?, ?]> to memref<?x5x?x1xf32, offset: ?, strides: [?, ?, ?, ?]>
 
-  %18 = alloc() : memref<1x8xf32>
+  %18 = memref.alloc() : memref<1x8xf32>
   // CHECK: subview %18[0, 0] [1, 8] [1, 1]  : memref<1x8xf32> to memref<8xf32>
   %19 = subview %18[0, 0][1, 8][1, 1] : memref<1x8xf32> to memref<8xf32>
 
-  %20 = alloc() : memref<8x16x4xf32>
+  %20 = memref.alloc() : memref<8x16x4xf32>
   // CHECK: subview %20[0, 0, 0] [1, 16, 4] [1, 1, 1]  : memref<8x16x4xf32> to memref<16x4xf32>
   %21 = subview %20[0, 0, 0][1, 16, 4][1, 1, 1] : memref<8x16x4xf32> to memref<16x4xf32>
 
   %22 = subview %20[3, 4, 2][1, 6, 3][1, 1, 1] : memref<8x16x4xf32> to memref<6x3xf32, offset: 210, strides: [4, 1]>
 
-  %23 = alloc() : memref<f32>
+  %23 = memref.alloc() : memref<f32>
   %78 = subview %23[] [] []  : memref<f32> to memref<f32>
 
   /// Subview with only leading operands.
-  %24 = alloc() : memref<5x3xf32>
+  %24 = memref.alloc() : memref<5x3xf32>
   // CHECK: subview %{{.*}}[2] [3] [1] : memref<5x3xf32> to memref<3x3xf32, #[[$SUBVIEW_MAP9]]>
   %25 = subview %24[2][3][1]: memref<5x3xf32> to memref<3x3xf32, offset: 6, strides: [3, 1]>
 
   /// Rank-reducing subview with only leading operands.
   // CHECK: subview %{{.*}}[1] [1] [1] : memref<5x3xf32> to memref<3xf32, #[[$SUBVIEW_MAP10]]>
   %26 = subview %24[1][1][1]: memref<5x3xf32> to memref<3xf32, offset: 3, strides: [1]>
 
   // Corner-case of 0-D rank-reducing subview with an offset.
   // CHECK: subview %{{.*}}[1, 1] [1, 1] [1, 1] : memref<5x3xf32> to memref<f32, #[[$SUBVIEW_MAP11]]>
   %27 = subview %24[1, 1] [1, 1] [1, 1] : memref<5x3xf32> to memref<f32, affine_map<() -> (4)>>
 
   // CHECK: subview %{{.*}}[%{{.*}}, 1] [1, 1] [1, 1] : memref<5x3xf32> to memref<f32, #[[$SUBVIEW_MAP12]]>
   %28 = subview %24[%arg0, 1] [1, 1] [1, 1] : memref<5x3xf32> to memref<f32, affine_map<()[s0] -> (s0)>>
 
   // CHECK: subview %{{.*}}[0, %{{.*}}] [%{{.*}}, 1] [1, 1] : memref<?x?xf32> to memref<?xf32, #[[$SUBVIEW_MAP1]]>
-  %a30 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %a30 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %30 = subview %a30[0, %arg1][%arg2, 1][1, 1] : memref<?x?xf32> to memref<?xf32, affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>>
 
   return
 }
 
 // CHECK-LABEL: func @test_dimop
 // CHECK-SAME: %[[ARG:.*]]: tensor<4x4x?xf32>
 func @test_dimop(%arg0: tensor<4x4x?xf32>) {

mlir/test/IR/invalid-ops.mlir

 
 // -----
 
 func @bad_alloc_wrong_dynamic_dim_count() {
 ^bb0:
   %0 = constant 7 : index
   // Test alloc with wrong number of dynamic dimensions.
   // expected-error@+1 {{dimension operand count does not equal memref dynamic dimension count}}
-  %1 = alloc(%0)[%0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+  %1 = memref.alloc(%0)[%0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
   return
 }
 
 // -----
 
 func @bad_alloc_wrong_symbol_count() {
 ^bb0:
   %0 = constant 7 : index
   // Test alloc with wrong number of symbols
   // expected-error@+1 {{symbol operand count does not equal memref symbol count}}
-  %1 = alloc(%0) : memref<2x?xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+  %1 = memref.alloc(%0) : memref<2x?xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
   return
 }
 
 // -----
 
 func @test_store_zero_results() {
 ^bb0:
-  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  %0 = memref.alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
   %1 = constant 0 : index
   %2 = constant 1 : index
   %3 = load %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
   // Test that store returns zero results.
-  %4 = store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1> // expected-error {{cannot name an operation with no results}}
+  %4 = memref.store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1> // expected-error {{cannot name an operation with no results}}
   return
 }
 
 // -----
 
 func @test_store_zero_results2(%x: i32, %p: memref<i32>) {
-  "std.store"(%x,%p) : (i32, memref<i32>) -> i32  // expected-error {{'std.store' op requires zero results}}
+  "memref.store"(%x,%p) : (i32, memref<i32>) -> i32  // expected-error {{'memref.store' op requires zero results}}
   return
 }
 
 // -----
 
 func @test_alloc_memref_map_rank_mismatch() {
 ^bb0:
-  %0 = alloc() : memref<1024x64xf32, affine_map<(d0) -> (d0)>, 1> // expected-error {{memref affine map dimension mismatch}}
+  %0 = memref.alloc() : memref<1024x64xf32, affine_map<(d0) -> (d0)>, 1> // expected-error {{memref affine map dimension mismatch}}
   return
 }
 
 // -----
 
 func @intlimit2() {
 ^bb:
   %0 = "std.constant"() {value = 0} : () -> i16777215
func @dma_start_src_index_wrong_type(
   // expected-error@+1 {{expected source indices to be of index type}}
   "std.dma_start"(%src, %idx, %flt, %dst, %idx, %tag, %idx)
       : (memref<2x2xf32>, index, f32, memref<2xf32,1>, index, memref<i32,2>, index) -> ()
 }
 
 // -----
 
 func @dma_no_dst_memref(%m : f32, %tag : f32, %c0 : index) {
-  %mref = alloc() : memref<8 x f32>
+  %mref = memref.alloc() : memref<8 x f32>
   // expected-error@+1 {{expected destination to be of memref type}}
   dma_start %mref[%c0], %m[%c0], %c0, %tag[%c0] : memref<8 x f32>, f32, f32
 }
 
 // -----
 
 func @dma_start_not_enough_operands_for_dst(
     %src: memref<2x2xf32>, %idx: index, %dst: memref<2xf32,1>,
func @dma_start_dst_index_wrong_type(
   // expected-error@+1 {{expected num elements to be of index type}}
   "std.dma_start"(%src, %idx, %idx, %dst, %idx, %flt, %tag)
       : (memref<2x2xf32>, index, index, memref<2xf32,1>, index, f32, memref<i32,2>) -> ()
 }
 
 // -----
 
 func @dma_no_tag_memref(%tag : f32, %c0 : index) {
-  %mref = alloc() : memref<8 x f32>
+  %mref = memref.alloc() : memref<8 x f32>
   // expected-error@+1 {{expected tag to be of memref type}}
   dma_start %mref[%c0], %mref[%c0], %c0, %tag[%c0] : memref<8 x f32>, memref<8 x f32>, f32
 }
 
 // -----
 
 func @dma_start_not_enough_operands_for_tag(
     %src: memref<2x2xf32>, %idx: index, %dst: memref<2xf32,1>,
func @invalid_splat(%v : f32) { // expected-note {{prior use here}}
   splat %v : vector<8xf64>
   // expected-error@-1 {{expects different type than prior uses}}
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
   // expected-error@+1 {{expects 1 offset operand}}
-  %1 = view %0[][%arg0, %arg1]
+  %1 = memref.view %0[][%arg0, %arg1]
     : memref<2048xi8> to memref<?x?xf32>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>>
+  %0 = memref.alloc() : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>>
   // expected-error@+1 {{unsupported map for base memref type}}
-  %1 = view %0[%arg2][%arg0, %arg1]
+  %1 = memref.view %0[%arg2][%arg0, %arg1]
     : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>> to
       memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
   // expected-error@+1 {{unsupported map for result memref type}}
-  %1 = view %0[%arg2][%arg0, %arg1]
+  %1 = memref.view %0[%arg2][%arg0, %arg1]
     : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0, d1, s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8, 2>
+  %0 = memref.alloc() : memref<2048xi8, 2>
   // expected-error@+1 {{different memory spaces}}
-  %1 = view %0[%arg2][%arg0, %arg1] :  memref<2048xi8, 2> to memref<?x?xf32, 1>
+  %1 = memref.view %0[%arg2][%arg0, %arg1] :  memref<2048xi8, 2> to memref<?x?xf32, 1>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
   // expected-error@+1 {{incorrect number of size operands for type}}
-  %1 = view %0[%arg2][%arg0]
+  %1 = memref.view %0[%arg2][%arg0]
     : memref<2048xi8> to memref<?x?xf32>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected mixed offsets rank to match mixed sizes rank (2 vs 3) so the rank of the result type is well-formed}}
   %1 = subview %0[0, 0][2, 2, 2][1, 1, 1]
     : memref<8x16x4xf32> to memref<8x16x4xf32>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected mixed sizes rank to match mixed strides rank (3 vs 2) so the rank of the result type is well-formed}}
   %1 = subview %0[0, 0, 0][2, 2, 2][1, 1]
     : memref<8x16x4xf32> to memref<8x16x4xf32>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected mixed sizes rank to match mixed strides rank (3 vs 2) so the rank of the result type is well-formed}}
   %1 = memref_reinterpret_cast %0 to offset: [0], sizes: [2, 2, 2], strides:[1, 1]
     : memref<8x16x4xf32> to memref<8x16x4xf32>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2>
+  %0 = memref.alloc() : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2>
   // expected-error@+1 {{different memory spaces}}
   %1 = subview %0[0, 0, 0][%arg2, %arg2, %arg2][1, 1, 1]
     : memref<8x16x4xf32, offset: 0, strides: [64, 4, 1], 2> to
       memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>>
+  %0 = memref.alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>>
   // expected-error@+1 {{is not strided}}
   %1 = subview %0[0, 0, 0][%arg2, %arg2, %arg2][1, 1, 1]
     : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>> to
       memref<8x?x4xf32, offset: 0, strides: [?, 4, 1]>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected <= 3 offset values}}
   %1 = subview %0[%arg0, %arg1, 0, 0][%arg2, 0, 0, 0][1, 1, 1, 1]
     : memref<8x16x4xf32> to
       memref<8x?x4xf32, offset: 0, strides:[?, ?, 4]>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected result type to be 'memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)>>' or a rank-reduced version. (mismatch of result affine map)}}
   %1 = subview %0[%arg0, %arg1, %arg2][%arg0, %arg1, %arg2][%arg0, %arg1, %arg2]
     : memref<8x16x4xf32> to
       memref<?x?x?xf32, offset: ?, strides: [64, 4, 1]>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected result element type to be 'f32'}}
   %1 = subview %0[0, 0, 0][8, 16, 4][1, 1, 1]
     : memref<8x16x4xf32> to
       memref<8x16x4xi32>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected result rank to be smaller or equal to the source rank.}}
   %1 = subview %0[0, 0, 0][8, 16, 4][1, 1, 1]
     : memref<8x16x4xf32> to
       memref<8x16x4x3xi32>
   return
 }
 
 // -----
 
 func @invalid_rank_reducing_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected result type to be 'memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>' or a rank-reduced version. (mismatch of result sizes)}}
   %1 = subview %0[0, 0, 0][8, 16, 4][1, 1, 1]
     : memref<8x16x4xf32> to memref<16x4xf32>
   return
 }
 
 // -----
 
 func @invalid_rank_reducing_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32>
+  %0 = memref.alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected result type to be 'memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 8)>>' or a rank-reduced version. (mismatch of result sizes)}}
   %1 = subview %0[0, 2, 0][8, 16, 4][1, 1, 1]
     : memref<8x16x4xf32> to memref<16x4xf32>
   return
 }
 
 // -----
 
func @invalid_rank_reducing_subview(%arg0 : memref<?x?xf32>, %arg1 : index, %arg2 : index) {
   %0 = subview %arg0[0, %arg1][%arg2, 1][1, 1] : memref<?x?xf32> to memref<?xf32, affine_map<(d0)[s0, s1, s2] -> (d0 * s1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_memref_cast(%arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]>) {
   // expected-error@+1{{operand type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>>' and result type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 128 + d1 * 32 + d2 * 2)>>' are cast incompatible}}
-  %0 = memref_cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:0, strides:[128, 32, 2]>
+  %0 = memref.cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:0, strides:[128, 32, 2]>
   return
 }
 
 // -----
 
 func @invalid_memref_cast(%arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]>) {
   // expected-error@+1{{operand type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>>' and result type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2 + 16)>>' are cast incompatible}}
-  %0 = memref_cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:16, strides:[64, 16, 1]>
+  %0 = memref.cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:16, strides:[64, 16, 1]>
   return
 }
 
 // -----
 
 // incompatible element types
 func @invalid_memref_cast() {
-  %0 = alloc() : memref<2x5xf32, 0>
+  %0 = memref.alloc() : memref<2x5xf32, 0>
   // expected-error@+1 {{operand type 'memref<2x5xf32>' and result type 'memref<*xi32>' are cast incompatible}}
-  %1 = memref_cast %0 : memref<2x5xf32, 0> to memref<*xi32>
+  %1 = memref.cast %0 : memref<2x5xf32, 0> to memref<*xi32>
   return
 }
 
 // -----
 
 func @invalid_prefetch_rw(%i : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   // expected-error@+1 {{rw specifier has to be 'read' or 'write'}}
-  prefetch %0[%i], rw, locality<0>, data  : memref<10xf32>
+  memref.prefetch %0[%i], rw, locality<0>, data  : memref<10xf32>
   return
 }
 
 // -----
 
 func @invalid_prefetch_cache_type(%i : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   // expected-error@+1 {{cache type has to be 'data' or 'instr'}}
-  prefetch %0[%i], read, locality<0>, false  : memref<10xf32>
+  memref.prefetch %0[%i], read, locality<0>, false  : memref<10xf32>
   return
 }
 
 // -----
 
 func @invalid_prefetch_locality_hint(%i : index) {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   // expected-error@+1 {{32-bit signless integer attribute whose minimum value is 0 whose maximum value is 3}}
-  prefetch %0[%i], read, locality<5>, data  : memref<10xf32>
+  memref.prefetch %0[%i], read, locality<5>, data  : memref<10xf32>
   return
 }
 
 // -----
 
 // incompatible memory space
 func @invalid_memref_cast() {
-  %0 = alloc() : memref<2x5xf32, 0>
+  %0 = memref.alloc() : memref<2x5xf32, 0>
   // expected-error@+1 {{operand type 'memref<2x5xf32>' and result type 'memref<*xf32, 1>' are cast incompatible}}
-  %1 = memref_cast %0 : memref<2x5xf32, 0> to memref<*xf32, 1>
+  %1 = memref.cast %0 : memref<2x5xf32, 0> to memref<*xf32, 1>
   return
 }
 
 // -----
 
 // unranked to unranked
 func @invalid_memref_cast() {
-  %0 = alloc() : memref<2x5xf32, 0>
-  %1 = memref_cast %0 : memref<2x5xf32, 0> to memref<*xf32, 0>
+  %0 = memref.alloc() : memref<2x5xf32, 0>
+  %1 = memref.cast %0 : memref<2x5xf32, 0> to memref<*xf32, 0>
   // expected-error@+1 {{operand type 'memref<*xf32>' and result type 'memref<*xf32>' are cast incompatible}}
-  %2 = memref_cast %1 : memref<*xf32, 0> to memref<*xf32, 0>
+  %2 = memref.cast %1 : memref<*xf32, 0> to memref<*xf32, 0>
   return
 }
 
 // -----
 
 func @atomic_rmw_idxs_rank_mismatch(%I: memref<16x10xf32>, %i : index, %val : f32) {
   // expected-error@+1 {{expects the number of subscripts to be equal to memref rank}}
   %x = atomic_rmw addf %val, %I[%i] : (f32, memref<16x10xf32>) -> f32

 
 // -----
 
 func @generic_atomic_rmw_has_side_effects(%I: memref<10xf32>, %i : index) {
   // expected-error@+4 {{should contain only operations with no side effects}}
   %x = generic_atomic_rmw %I[%i] : memref<10xf32> {
     ^bb0(%old_value : f32):
       %c1 = constant 1.0 : f32
-      %buf = alloc() : memref<2048xf32>
+      %buf = memref.alloc() : memref<2048xf32>
       atomic_yield %c1 : f32
   }
 }
 
 // -----
 
 func @atomic_yield_type_mismatch(%I: memref<10xf32>, %i : index) {
   // expected-error@+4 {{op types mismatch between yield op: 'i32' and its parent: 'f32'}}
func @assume_alignment(%0: memref<4x4xf16>) {
   // expected-error@+1 {{attribute 'alignment' failed to satisfy constraint: 32-bit signless integer attribute whose value is positive}}
   std.assume_alignment %0, 0 : memref<4x4xf16>
   return
 }
 
 // -----
 
 "alloca_without_scoped_alloc_parent"() ( {
-  std.alloca() : memref<1xf32>
+  memref.alloca() : memref<1xf32>
   // expected-error@-1 {{requires an ancestor op with AutomaticAllocationScope trait}}
   return
 }) : () -> ()
 
 // -----
 
 func @subtensor_wrong_dynamic_type(%t: tensor<8x16x4xf32>, %idx : index) {
       // expected-error @+1 {{expected result type to be 'tensor<4x4x4xf32>' or a rank-reduced version. (mismatch of result sizes)}}

mlir/test/IR/memory-ops.mlir

 // RUN: mlir-opt %s | FileCheck %s
 
 // CHECK: #map = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
 
 // CHECK-LABEL: func @alloc() {
 func @alloc() {
 ^bb0:
   // Test simple alloc.
-  // CHECK: %0 = alloc() : memref<1024x64xf32, 1>
-  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: %0 = memref.alloc() : memref<1024x64xf32, 1>
+  %0 = memref.alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %c0 = "std.constant"() {value = 0: index} : () -> index
   %c1 = "std.constant"() {value = 1: index} : () -> index
 
   // Test alloc with dynamic dimensions.
-  // CHECK: %1 = alloc(%c0, %c1) : memref<?x?xf32, 1>
-  %1 = alloc(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: %1 = memref.alloc(%c0, %c1) : memref<?x?xf32, 1>
+  %1 = memref.alloc(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // Test alloc with no dynamic dimensions and one symbol.
-  // CHECK: %2 = alloc()[%c0] : memref<2x4xf32, #map, 1>
-  %2 = alloc()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+  // CHECK: %2 = memref.alloc()[%c0] : memref<2x4xf32, #map, 1>
+  %2 = memref.alloc()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
 
   // Test alloc with dynamic dimensions and one symbol.
-  // CHECK: %3 = alloc(%c1)[%c0] : memref<2x?xf32, #map, 1>
-  %3 = alloc(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
+  // CHECK: %3 = memref.alloc(%c1)[%c0] : memref<2x?xf32, #map, 1>
+  %3 = memref.alloc(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
 
   // Alloc with no mappings.
   // b/116054838 Parser crash while parsing ill-formed AllocOp
-  // CHECK: %4 = alloc() : memref<2xi32>
-  %4 = alloc() : memref<2 x i32>
+  // CHECK: %4 = memref.alloc() : memref<2xi32>
+  %4 = memref.alloc() : memref<2 x i32>
 
   // CHECK:   return
   return
 }
 
 // CHECK-LABEL: func @alloca() {
 func @alloca() {
 ^bb0:
   // Test simple alloc.
-  // CHECK: %0 = alloca() : memref<1024x64xf32, 1>
-  %0 = alloca() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: %0 = memref.alloca() : memref<1024x64xf32, 1>
+  %0 = memref.alloca() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %c0 = "std.constant"() {value = 0: index} : () -> index
   %c1 = "std.constant"() {value = 1: index} : () -> index
 
   // Test alloca with dynamic dimensions.
-  // CHECK: %1 = alloca(%c0, %c1) : memref<?x?xf32, 1>
-  %1 = alloca(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: %1 = memref.alloca(%c0, %c1) : memref<?x?xf32, 1>
+  %1 = memref.alloca(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // Test alloca with no dynamic dimensions and one symbol.
-  // CHECK: %2 = alloca()[%c0] : memref<2x4xf32, #map, 1>
-  %2 = alloca()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
+  // CHECK: %2 = memref.alloca()[%c0] : memref<2x4xf32, #map, 1>
+  %2 = memref.alloca()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
 
   // Test alloca with dynamic dimensions and one symbol.
-  // CHECK: %3 = alloca(%c1)[%c0] : memref<2x?xf32, #map, 1>
-  %3 = alloca(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
+  // CHECK: %3 = memref.alloca(%c1)[%c0] : memref<2x?xf32, #map, 1>
+  %3 = memref.alloca(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
 
   // Alloca with no mappings, but with alignment.
-  // CHECK: %4 = alloca() {alignment = 64 : i64} : memref<2xi32>
-  %4 = alloca() {alignment = 64} : memref<2 x i32>
+  // CHECK: %4 = memref.alloca() {alignment = 64 : i64} : memref<2xi32>
+  %4 = memref.alloca() {alignment = 64} : memref<2 x i32>
 
   return
 }
 
 // CHECK-LABEL: func @dealloc() {
 func @dealloc() {
 ^bb0:
-  // CHECK: %0 = alloc() : memref<1024x64xf32>
-  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
+  // CHECK: %0 = memref.alloc() : memref<1024x64xf32>
+  %0 = memref.alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
 
-  // CHECK: dealloc %0 : memref<1024x64xf32>
-  dealloc %0 : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
+  // CHECK: memref.dealloc %0 : memref<1024x64xf32>
+  memref.dealloc %0 : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
   return
 }
 
 // CHECK-LABEL: func @load_store
 func @load_store() {
 ^bb0:
-  // CHECK: %0 = alloc() : memref<1024x64xf32, 1>
-  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: %0 = memref.alloc() : memref<1024x64xf32, 1>
+  %0 = memref.alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %1 = constant 0 : index
   %2 = constant 1 : index
 
   // CHECK: %1 = load %0[%c0, %c1] : memref<1024x64xf32, 1>
   %3 = load %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
-  // CHECK: store %1, %0[%c0, %c1] : memref<1024x64xf32, 1>
-  store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
+  // CHECK: memref.store %1, %0[%c0, %c1] : memref<1024x64xf32, 1>
+  memref.store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   return
 }
 
 // CHECK-LABEL: func @dma_ops()
 func @dma_ops() {
   %c0 = constant 0 : index
   %stride = constant 32 : index
   %elt_per_stride = constant 16 : index
 
-  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
-  %Ah = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 1>
-  %tag = alloc() : memref<1 x f32>
+  %A = memref.alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = memref.alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 1>
+  %tag = memref.alloc() : memref<1 x f32>
 
   %num_elements = constant 256 : index
 
   dma_start %A[%c0], %Ah[%c0], %num_elements, %tag[%c0] : memref<256 x f32>, memref<256 x f32, 1>, memref<1 x f32>
   dma_wait %tag[%c0], %num_elements : memref<1 x f32>
   // CHECK: dma_start %0[%c0], %1[%c0], %c256, %2[%c0] : memref<256xf32>, memref<256xf32, 1>, memref<1xf32>
   // CHECK-NEXT:  dma_wait %2[%c0], %c256 : memref<1xf32>
 
   // DMA with strides
   dma_start %A[%c0], %Ah[%c0], %num_elements, %tag[%c0], %stride, %elt_per_stride : memref<256 x f32>, memref<256 x f32, 1>, memref<1 x f32>
   dma_wait %tag[%c0], %num_elements : memref<1 x f32>
   // CHECK-NEXT:  dma_start %0[%c0], %1[%c0], %c256, %2[%c0], %c32, %c16 : memref<256xf32>, memref<256xf32, 1>, memref<1xf32>
   // CHECK-NEXT:  dma_wait %2[%c0], %c256 : memref<1xf32>
 
   return
 }

mlir/test/IR/parser.mlir

func @complex_loops() {
   return                    // CHECK:   return
 }                           // CHECK: }
 
 // CHECK: func @triang_loop(%{{.*}}: index, %{{.*}}: memref<?x?xi32>) {
 func @triang_loop(%arg0: index, %arg1: memref<?x?xi32>) {
   %c = constant 0 : i32       // CHECK: %{{.*}} = constant 0 : i32
   affine.for %i0 = 1 to %arg0 {      // CHECK: affine.for %{{.*}} = 1 to %{{.*}} {
     affine.for %i1 = affine_map<(d0)[]->(d0)>(%i0)[] to %arg0 {  // CHECK:   affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} {
-      store %c, %arg1[%i0, %i1] : memref<?x?xi32>  // CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}]
+      memref.store %c, %arg1[%i0, %i1] : memref<?x?xi32>  // CHECK: memref.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}]
     }          // CHECK:     }
   }            // CHECK:   }
   return       // CHECK:   return
 }              // CHECK: }
 
 // CHECK: func @minmax_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: memref<100xf32>) {
 func @minmax_loop(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
   // CHECK: affine.for %{{.*}} = max #map{{.*}}()[%{{.*}}] to min #map{{.*}}()[%{{.*}}] {

mlir/test/IR/slice.mlir

 // RUN: mlir-opt -slice-analysis-test %s | FileCheck %s
 
 func @slicing_linalg_op(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %a = alloc(%arg0, %arg2) : memref<?x?xf32>
-  %b = alloc(%arg2, %arg1) : memref<?x?xf32>
-  %c = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %d = alloc(%arg0, %arg1) : memref<?x?xf32>
+  %a = memref.alloc(%arg0, %arg2) : memref<?x?xf32>
+  %b = memref.alloc(%arg2, %arg1) : memref<?x?xf32>
+  %c = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %d = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
   linalg.matmul ins(%a, %b : memref<?x?xf32>, memref<?x?xf32>)
                outs(%c : memref<?x?xf32>)
   linalg.matmul ins(%a, %b : memref<?x?xf32>, memref<?x?xf32>)
                outs(%d : memref<?x?xf32>)
-  dealloc %c : memref<?x?xf32>
-  dealloc %b : memref<?x?xf32>
-  dealloc %a : memref<?x?xf32>
-  dealloc %d : memref<?x?xf32>
+  memref.dealloc %c : memref<?x?xf32>
+  memref.dealloc %b : memref<?x?xf32>
+  memref.dealloc %a : memref<?x?xf32>
+  memref.dealloc %d : memref<?x?xf32>
   return
 }
 
 // CHECK-LABEL: func @slicing_linalg_op__backward_slice__0
 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: index
 //  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]+]]: index
 //  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]+]]: index
-//   CHECK-DAG:   %[[A:.+]] = alloc(%[[ARG0]], %[[ARG2]]) : memref<?x?xf32>
-//   CHECK-DAG:   %[[B:.+]] = alloc(%[[ARG2]], %[[ARG1]]) : memref<?x?xf32>
-//   CHECK-DAG:   %[[C:.+]] = alloc(%[[ARG0]], %[[ARG1]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[A:.+]] = memref.alloc(%[[ARG0]], %[[ARG2]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[B:.+]] = memref.alloc(%[[ARG2]], %[[ARG1]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[C:.+]] = memref.alloc(%[[ARG0]], %[[ARG1]]) : memref<?x?xf32>
 //       CHECK:   return
 
 // CHECK-LABEL: func @slicing_linalg_op__backward_slice__1
 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: index
 //  CHECK-SAME:   %[[ARG1:[a-zA-Z0-9_]+]]: index
 //  CHECK-SAME:   %[[ARG2:[a-zA-Z0-9_]+]]: index
-//   CHECK-DAG:   %[[A:.+]] = alloc(%[[ARG0]], %[[ARG2]]) : memref<?x?xf32>
-//   CHECK-DAG:   %[[B:.+]] = alloc(%[[ARG2]], %[[ARG1]]) : memref<?x?xf32>
-//   CHECK-DAG:   %[[C:.+]] = alloc(%[[ARG0]], %[[ARG1]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[A:.+]] = memref.alloc(%[[ARG0]], %[[ARG2]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[B:.+]] = memref.alloc(%[[ARG2]], %[[ARG1]]) : memref<?x?xf32>
+//   CHECK-DAG:   %[[C:.+]] = memref.alloc(%[[ARG0]], %[[ARG1]]) : memref<?x?xf32>
 //       CHECK:   return

mlir/test/Transforms/buffer-deallocation.mlir

 // moved to bb0, we need to insert allocs and copies.
 
 // CHECK-LABEL: func @condBranch
 func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
 // CHECK-NEXT: br ^bb3(%[[ALLOC0]]
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC2:.*]] = alloc()
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
-// CHECK-NEXT: dealloc %[[ALLOC1]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
 // CHECK-NEXT: br ^bb3(%[[ALLOC2]]
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc
+// CHECK-NEXT: memref.dealloc
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  bb1  bb2 <- Initial position of AllocOp
func @condBranchDynamicType(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb3(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   br ^bb3(%1 : memref<?xf32>)
 ^bb3(%2: memref<?xf32>):
   test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: %[[DIM0:.*]] = dim
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[DIM0]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[DIM0]])
 // CHECK-NEXT: linalg.copy(%{{.*}}, %[[ALLOC0]])
 // CHECK-NEXT: br ^bb3(%[[ALLOC0]]
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 //      CHECK: %[[DIM1:.*]] = dim %[[ALLOC1]]
-// CHECK-NEXT: %[[ALLOC2:.*]] = alloc(%[[DIM1]])
+// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc(%[[DIM1]])
 // CHECK-NEXT: linalg.copy(%[[ALLOC1]], %[[ALLOC2]])
-// CHECK-NEXT: dealloc %[[ALLOC1]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
 // CHECK-NEXT: br ^bb3
 // CHECK-NEXT: ^bb3(%[[ALLOC3:.*]]:{{.*}})
 //      CHECK: test.copy(%[[ALLOC3]],
-// CHECK-NEXT: dealloc %[[ALLOC3]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //      bb0
 //     /    \
 //   bb1    bb2 <- Initial position of AllocOp
func @condBranchDynamicTypeNested(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb6(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   cond_br %arg0, ^bb3, ^bb4
 ^bb3:
   br ^bb5(%1 : memref<?xf32>)
 ^bb4:
   br ^bb5(%1 : memref<?xf32>)
 ^bb5(%2: memref<?xf32>):
   br ^bb6(%2 : memref<?xf32>)
 ^bb6(%3: memref<?xf32>):
   br ^bb7(%3 : memref<?xf32>)
 ^bb7(%4: memref<?xf32>):
   test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb1
 //      CHECK: %[[DIM0:.*]] = dim
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[DIM0]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[DIM0]])
 // CHECK-NEXT: linalg.copy(%{{.*}}, %[[ALLOC0]])
 // CHECK-NEXT: br ^bb6
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 //      CHECK: cond_br
 //      CHECK: ^bb3:
 // CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}})
 //      CHECK: ^bb4:
 // CHECK-NEXT: br ^bb5(%[[ALLOC1]]{{.*}})
 // CHECK-NEXT: ^bb5(%[[ALLOC2:.*]]:{{.*}})
 //      CHECK: %[[DIM2:.*]] = dim %[[ALLOC2]]
-// CHECK-NEXT: %[[ALLOC3:.*]] = alloc(%[[DIM2]])
+// CHECK-NEXT: %[[ALLOC3:.*]] = memref.alloc(%[[DIM2]])
 // CHECK-NEXT: linalg.copy(%[[ALLOC2]], %[[ALLOC3]])
-// CHECK-NEXT: dealloc %[[ALLOC1]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
 // CHECK-NEXT: br ^bb6(%[[ALLOC3]]{{.*}})
 // CHECK-NEXT: ^bb6(%[[ALLOC4:.*]]:{{.*}})
 // CHECK-NEXT: br ^bb7(%[[ALLOC4]]{{.*}})
 // CHECK-NEXT: ^bb7(%[[ALLOC5:.*]]:{{.*}})
 //      CHECK: test.copy(%[[ALLOC5]],
-// CHECK-NEXT: dealloc %[[ALLOC4]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Existing AllocOp with no users.
 // BufferDeallocation expected behavior: It should insert a DeallocOp right
 // before ReturnOp.
 
 // CHECK-LABEL: func @emptyUsesValue
 func @emptyUsesValue(%arg0: memref<4xf32>) {
-  %0 = alloc() : memref<4xf32>
+  %0 = memref.alloc() : memref<4xf32>
   return
 }
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
-// CHECK-NEXT: dealloc %[[ALLOC]]
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
+// CHECK-NEXT: memref.dealloc %[[ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  |    bb1 <- Initial position of AllocOp
 //   \   /
 //    bb2
 // BufferDeallocation expected behavior: It should insert a DeallocOp at the
 // exit block after CopyOp since %1 is an alias for %0 and %arg1. Furthermore,
 // we have to insert a copy and an alloc in the beginning of the function.
 
 // CHECK-LABEL: func @criticalEdge
 func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb2(%0 : memref<2xf32>)
 ^bb2(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
 // CHECK-NEXT: cond_br
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC2:.*]] = alloc()
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
-// CHECK-NEXT: dealloc %[[ALLOC1]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC1]]
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc
+// CHECK-NEXT: memref.dealloc
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0 <- Initial position of AllocOp
 //   /   \
 //  |    bb1
 //   \   /
 //    bb2
 // BufferDeallocation expected behavior: It only inserts a DeallocOp at the
 // exit block after CopyOp since %1 is an alias for %0 and %arg1.
 
 // CHECK-LABEL: func @invCriticalEdge
 func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
 ^bb1:
   br ^bb2(%0 : memref<2xf32>)
 ^bb2(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }

 //    bb3 <- Initial position of the second AllocOp
 // BufferDeallocation expected behavior: It only inserts two missing
 // DeallocOps in the exit block. %5 is an alias for %0. Therefore, the
 // DeallocOp for %0 should occur after the last BufferBasedOp. The Dealloc for
 // %7 should happen after CopyOp.
 
 // CHECK-LABEL: func @ifElse
 func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
-  %7 = alloc() : memref<2xf32>
+  %7 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
   test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[SECOND_ALLOC:.*]] = alloc()
+//      CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: dealloc %[[FIRST_ALLOC]]
+//      CHECK: memref.dealloc %[[FIRST_ALLOC]]
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[SECOND_ALLOC]]
+// CHECK-NEXT: memref.dealloc %[[SECOND_ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: No users for buffer in if-else CFG
 //    bb0 <- Initial position of AllocOp
 //   /   \
 //  bb1  bb2
 //   \   /
 //    bb3
 // BufferDeallocation expected behavior: It only inserts a missing DeallocOp
 // in the exit block since %5 or %6 are the latest aliases of %0.
 
 // CHECK-LABEL: func @ifElseNoUsers
 func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
   test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[FIRST_ALLOC]]
+// CHECK-NEXT: memref.dealloc %[[FIRST_ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //      bb0 <- Initial position of the first AllocOp
 //     /    \
 //   bb1    bb2
 //    |     /  \
 //    |   bb3  bb4
 //    \     \  /
 //     \     /
 //       bb5 <- Initial position of the second AllocOp
 // BufferDeallocation expected behavior: Two missing DeallocOps should be
 // inserted in the exit block.
 
 // CHECK-LABEL: func @ifElseNested
 func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
 ^bb3(%5: memref<2xf32>):
   br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
 ^bb4(%6: memref<2xf32>):
   br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
 ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
-  %9 = alloc() : memref<2xf32>
+  %9 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
   test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[SECOND_ALLOC:.*]] = alloc()
+//      CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: dealloc %[[FIRST_ALLOC]]
+//      CHECK: memref.dealloc %[[FIRST_ALLOC]]
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[SECOND_ALLOC]]
+// CHECK-NEXT: memref.dealloc %[[SECOND_ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Dead operations in a single block.
 // BufferDeallocation expected behavior: It only inserts the two missing
 // DeallocOps after the last BufferBasedOp.
 
 // CHECK-LABEL: func @redundantOperations
 func @redundantOperations(%arg0: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%0: memref<2xf32>) out(%1: memref<2xf32>)
   return
 }
 
 //      CHECK: (%[[ARG0:.*]]: {{.*}})
-// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[FIRST_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based in(%[[ARG0]]{{.*}}out(%[[FIRST_ALLOC]]
-//      CHECK: %[[SECOND_ALLOC:.*]] = alloc()
+//      CHECK: %[[SECOND_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based in(%[[FIRST_ALLOC]]{{.*}}out(%[[SECOND_ALLOC]]
 //      CHECK: dealloc
 // CHECK-NEXT: dealloc
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:

 
 // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
 func @moving_alloc_and_inserting_missing_dealloc(
   %cond: i1,
     %arg0: memref<2xf32>,
     %arg1: memref<2xf32>) {
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
   br ^exit(%0 : memref<2xf32>)
 ^bb2:
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
   br ^exit(%1 : memref<2xf32>)
 ^exit(%arg2: memref<2xf32>):
   test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb1
 //      CHECK: ^bb1
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
-// CHECK-NEXT: dealloc %[[ALLOC0]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
 // CHECK-NEXT: br ^bb3(%[[ALLOC1]]
 // CHECK-NEXT: ^bb2
-// CHECK-NEXT: %[[ALLOC2:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC3:.*]] = alloc()
+//      CHECK: %[[ALLOC3:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
-// CHECK-NEXT: dealloc %[[ALLOC2]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
 // CHECK-NEXT: br ^bb3(%[[ALLOC3]]
 // CHECK-NEXT: ^bb3(%[[ALLOC4:.*]]:{{.*}})
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC4]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Invalid position of the DeallocOp. There is a user after
 // deallocation.
 //   bb0
 //  /   \
 // bb1  bb2 <- Initial position of AllocOp
 //  \   /
 //   bb3
 // BufferDeallocation expected behavior: The existing DeallocOp should be
 // moved to exit block.
 
 // CHECK-LABEL: func @moving_invalid_dealloc_op_complex
 func @moving_invalid_dealloc_op_complex(
   %cond: i1,
     %arg0: memref<2xf32>,
     %arg1: memref<2xf32>) {
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
   br ^exit(%arg0 : memref<2xf32>)
 ^bb2:
   test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
-  dealloc %1 : memref<2xf32>
+  memref.dealloc %1 : memref<2xf32>
   br ^exit(%1 : memref<2xf32>)
 ^exit(%arg2: memref<2xf32>):
   test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: cond_br
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC0]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Inserting missing DeallocOp in a single block.
 
 // CHECK-LABEL: func @inserting_missing_dealloc_simple
 func @inserting_missing_dealloc_simple(
   %arg0 : memref<2xf32>,
   %arg1: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
   test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC0]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
 
 // -----
 
 // Test Case: Moving invalid DeallocOp (there is a user after deallocation) in a
 // single block.
 
 // CHECK-LABEL: func @moving_invalid_dealloc_op
 func @moving_invalid_dealloc_op(%arg0 : memref<2xf32>, %arg1: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
-  dealloc %0 : memref<2xf32>
+  memref.dealloc %0 : memref<2xf32>
   test.copy(%0, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC0]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
 
 // -----
 
 // Test Case: Nested regions - This test defines a BufferBasedOp inside the
 // region of a RegionBufferBasedOp.
 // BufferDeallocation expected behavior: The AllocOp for the BufferBasedOp
 // should remain inside the region of the RegionBufferBasedOp and it should insert
 // the missing DeallocOp in the same region. The missing DeallocOp should be
 // inserted after CopyOp.
 
 // CHECK-LABEL: func @nested_regions_and_cond_branch
 func @nested_regions_and_cond_branch(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloc() : memref<2xf32>
+    %1 = memref.alloc() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 //      CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
 // CHECK-NEXT:   cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
-//      CHECK:   %[[ALLOC0:.*]] = alloc()
+//      CHECK:   %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT:   linalg.copy(%[[ARG1]], %[[ALLOC0]])
 //      CHECK: ^[[BB2]]:
-//      CHECK:   %[[ALLOC1:.*]] = alloc()
+//      CHECK:   %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT:   test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
-//      CHECK:     %[[ALLOC2:.*]] = alloc()
+//      CHECK:     %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT:     test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC2]]
-//      CHECK:     dealloc %[[ALLOC2]]
+//      CHECK:     memref.dealloc %[[ALLOC2]]
 // CHECK-NEXT:     %{{.*}} = math.exp
-//      CHECK:   %[[ALLOC3:.*]] = alloc()
+//      CHECK:   %[[ALLOC3:.*]] = memref.alloc()
 // CHECK-NEXT:   linalg.copy(%[[ALLOC1]], %[[ALLOC3]])
-// CHECK-NEXT:   dealloc %[[ALLOC1]]
+// CHECK-NEXT:   memref.dealloc %[[ALLOC1]]
 //      CHECK:  ^[[BB3:.*]]({{.*}}):
 //      CHECK:  test.copy
 // CHECK-NEXT:  dealloc
 
 // -----
 
 // Test Case: buffer deallocation escaping
 // BufferDeallocation expected behavior: It must not dealloc %arg1 and %x
 // since they are operands of return operation and should escape from
 // deallocating. It should dealloc %y after CopyOp.
 
 // CHECK-LABEL: func @memref_in_function_results
 func @memref_in_function_results(
   %arg0: memref<5xf32>,
   %arg1: memref<10xf32>,
   %arg2: memref<5xf32>) -> (memref<10xf32>, memref<15xf32>) {
-  %x = alloc() : memref<15xf32>
-  %y = alloc() : memref<5xf32>
+  %x = memref.alloc() : memref<15xf32>
+  %y = memref.alloc() : memref<5xf32>
   test.buffer_based in(%arg0: memref<5xf32>) out(%y: memref<5xf32>)
   test.copy(%y, %arg2) : (memref<5xf32>, memref<5xf32>)
   return %arg1, %x : memref<10xf32>, memref<15xf32>
 }
 //      CHECK: (%[[ARG0:.*]]: memref<5xf32>, %[[ARG1:.*]]: memref<10xf32>,
 // CHECK-SAME: %[[RESULT:.*]]: memref<5xf32>)
-//      CHECK: %[[X:.*]] = alloc()
-//      CHECK: %[[Y:.*]] = alloc()
+//      CHECK: %[[X:.*]] = memref.alloc()
+//      CHECK: %[[Y:.*]] = memref.alloc()
 //      CHECK: test.copy
-//      CHECK: dealloc %[[Y]]
+//      CHECK: memref.dealloc %[[Y]]
 //      CHECK: return %[[ARG1]], %[[X]]
 
 // -----
 
 // Test Case: nested region control flow
 // The alloc %1 flows through both if branches until it is finally returned.
 // Hence, it does not require a specific dealloc operation. However, %3
 // requires a dealloc.
 
 // CHECK-LABEL: func @nested_region_control_flow
 func @nested_region_control_flow(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %1 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
 //      CHECK: scf.yield %[[ALLOC0]]
-//      CHECK: %[[ALLOC2:.*]] = alloc(%arg0, %arg1)
-// CHECK-NEXT: dealloc %[[ALLOC2]]
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc(%arg0, %arg1)
+// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
 // CHECK-NEXT: scf.yield %[[ALLOC0]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: nested region control flow with a nested buffer allocation in a
 // divergent branch.
 // Buffer deallocation places a copy for both  %1 and %3, since they are
 // returned in the end.
 
 // CHECK-LABEL: func @nested_region_control_flow_div
 func @nested_region_control_flow_div(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %3 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
-//      CHECK: %[[ALLOC2:.*]] = alloc
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc
 // CHECK-NEXT: linalg.copy(%[[ALLOC0]], %[[ALLOC2]])
 //      CHECK: scf.yield %[[ALLOC2]]
-//      CHECK: %[[ALLOC3:.*]] = alloc(%arg0, %arg1)
-//      CHECK: %[[ALLOC4:.*]] = alloc
+//      CHECK: %[[ALLOC3:.*]] = memref.alloc(%arg0, %arg1)
+//      CHECK: %[[ALLOC4:.*]] = memref.alloc
 // CHECK-NEXT: linalg.copy(%[[ALLOC3]], %[[ALLOC4]])
-//      CHECK: dealloc %[[ALLOC3]]
+//      CHECK: memref.dealloc %[[ALLOC3]]
 //      CHECK: scf.yield %[[ALLOC4]]
-//      CHECK: dealloc %[[ALLOC0]]
+//      CHECK: memref.dealloc %[[ALLOC0]]
 // CHECK-NEXT: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: nested region control flow within a region interface.
 // No copies are required in this case since the allocation finally escapes
 // the method.
 
 // CHECK-LABEL: func @inner_region_control_flow
 func @inner_region_control_flow(%arg0 : index) -> memref<?x?xf32> {
-  %0 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %1 = test.region_if %0 : memref<?x?xf32> -> (memref<?x?xf32>) then {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   } else {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   } join {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   }
   return %1 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %[[ALLOC1:.*]] = test.region_if
 // CHECK-NEXT: ^bb0(%[[ALLOC2:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC2]]
 //      CHECK: ^bb0(%[[ALLOC3:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC3]]
 //      CHECK: ^bb0(%[[ALLOC4:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC4]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // CHECK-LABEL: func @subview
 func @subview(%arg0 : index, %arg1 : index, %arg2 : memref<?x?xf32>) {
-  %0 = alloc() : memref<64x4xf32, offset: 0, strides: [4, 1]>
+  %0 = memref.alloc() : memref<64x4xf32, offset: 0, strides: [4, 1]>
   %1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] :
     memref<64x4xf32, offset: 0, strides: [4, 1]>
   to memref<?x?xf32, offset: ?, strides: [?, ?]>
   test.copy(%1, %arg2) :
     (memref<?x?xf32, offset: ?, strides: [?, ?]>, memref<?x?xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: subview
 // CHECK-NEXT: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
 // Therefore, all allocas are not handled.
 
 // CHECK-LABEL: func @condBranchAlloca
 func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloca() : memref<2xf32>
+  %0 = memref.alloca() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
-//      CHECK: %[[ALLOCA:.*]] = alloca()
+//      CHECK: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: br ^bb3(%[[ALLOCA:.*]])
 // CHECK-NEXT: ^bb3
 // CHECK-NEXT: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: In the presence of AllocaOps only the AllocOps has top be freed.
 // Therefore, all allocas are not handled. In this case, only alloc %0 has a
 // dealloc.
 
 // CHECK-LABEL: func @ifElseAlloca
 func @ifElseAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
-  %7 = alloca() : memref<2xf32>
+  %7 = memref.alloca() : memref<2xf32>
   test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
   test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOCA:.*]] = alloca()
+//      CHECK: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: dealloc %[[ALLOC]]
+//      CHECK: memref.dealloc %[[ALLOC]]
 //      CHECK: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // CHECK-LABEL: func @ifElseNestedAlloca
 func @ifElseNestedAlloca(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
-  %0 = alloca() : memref<2xf32>
+  %0 = memref.alloca() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
 ^bb3(%5: memref<2xf32>):
   br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
 ^bb4(%6: memref<2xf32>):
   br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
 ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
-  %9 = alloc() : memref<2xf32>
+  %9 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
   test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC:.*]] = alloc()
+//      CHECK: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 //      CHECK: test.copy
-// CHECK-NEXT: dealloc %[[ALLOC]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC]]
 // CHECK-NEXT: return
 
 // -----
 
 // CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca
 func @nestedRegionsAndCondBranchAlloca(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloca() : memref<2xf32>
+    %1 = memref.alloca() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 //      CHECK: (%[[cond:.*]]: {{.*}}, %[[ARG1:.*]]: {{.*}}, %{{.*}}: {{.*}})
 // CHECK-NEXT:   cond_br %[[cond]], ^[[BB1:.*]], ^[[BB2:.*]]
 //      CHECK: ^[[BB1]]:
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy
 //      CHECK: ^[[BB2]]:
-//      CHECK:   %[[ALLOC1:.*]] = alloc()
+//      CHECK:   %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT:   test.region_buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOC1]]
-//      CHECK:     %[[ALLOCA:.*]] = alloca()
+//      CHECK:     %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT:     test.buffer_based in(%[[ARG1]]{{.*}}out(%[[ALLOCA]]
 //      CHECK:     %{{.*}} = math.exp
-//      CHECK:  %[[ALLOC2:.*]] = alloc()
+//      CHECK:  %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT:  linalg.copy
-// CHECK-NEXT:  dealloc %[[ALLOC1]]
+// CHECK-NEXT:  memref.dealloc %[[ALLOC1]]
 //      CHECK:  ^[[BB3:.*]]({{.*}}):
 //      CHECK:  test.copy
 // CHECK-NEXT:  dealloc
 
 // -----
 
 // CHECK-LABEL: func @nestedRegionControlFlowAlloca
 func @nestedRegionControlFlowAlloca(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloca(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloca(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %1 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
 //      CHECK: scf.yield %[[ALLOC0]]
-//      CHECK: %[[ALLOCA:.*]] = alloca(%arg0, %arg1)
+//      CHECK: %[[ALLOCA:.*]] = memref.alloca(%arg0, %arg1)
 // CHECK-NEXT: scf.yield %[[ALLOC0]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: structured control-flow loop using a nested alloc.
 // The iteration argument %iterBuf has to be freed before yielding %3 to avoid
 // memory leaks.
 
 // CHECK-LABEL: func @loop_alloc
 func @loop_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
-    %3 = alloc() : memref<2xf32>
+    %3 = memref.alloc() : memref<2xf32>
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
-// CHECK-NEXT: dealloc %[[ALLOC0]]
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc()
 //      CHECK: linalg.copy(%arg3, %[[ALLOC1]])
 //      CHECK: %[[ALLOC2:.*]] = scf.for {{.*}} iter_args
 // CHECK-SAME: (%[[IALLOC:.*]] = %[[ALLOC1]]
 //      CHECK:    cmpi
-//      CHECK:    dealloc %[[IALLOC]]
-//      CHECK:    %[[ALLOC3:.*]] = alloc()
-//      CHECK:    %[[ALLOC4:.*]] = alloc()
+//      CHECK:    memref.dealloc %[[IALLOC]]
+//      CHECK:    %[[ALLOC3:.*]] = memref.alloc()
+//      CHECK:    %[[ALLOC4:.*]] = memref.alloc()
 //      CHECK:    linalg.copy(%[[ALLOC3]], %[[ALLOC4]])
-//      CHECK:    dealloc %[[ALLOC3]]
+//      CHECK:    memref.dealloc %[[ALLOC3]]
 //      CHECK:    scf.yield %[[ALLOC4]]
 //      CHECK: }
 //      CHECK: test.copy(%[[ALLOC2]], %arg4)
-// CHECK-NEXT: dealloc %[[ALLOC2]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC2]]
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation.
 // The loop yields buffers that have been defined outside of the loop and the
 // backedges only use the iteration arguments (or one of its aliases).
 // Therefore, we do not have to (and are not allowed to) free any buffers
 // that are passed via the backedges.
 
 // CHECK-LABEL: func @loop_nested_if_no_alloc
 func @loop_nested_if_no_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
       scf.yield %0 : memref<2xf32>
     } else {
       scf.yield %iterBuf : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.for {{.*}} iter_args(%[[IALLOC:.*]] =
 //      CHECK: %[[ALLOC2:.*]] = scf.if
 //      CHECK: scf.yield %[[ALLOC0]]
 //      CHECK: scf.yield %[[IALLOC]]
 //      CHECK: scf.yield %[[ALLOC2]]
 //      CHECK: test.copy(%[[ALLOC1]], %arg4)
-//      CHECK: dealloc %[[ALLOC0]]
+//      CHECK: memref.dealloc %[[ALLOC0]]
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation using
 // a deeply nested buffer allocation.
 // Since the innermost allocation happens in a divergent branch, we have to
 // introduce additional copies for the nested if operation. Since the loop's
 // yield operation "returns" %3, it will return a newly allocated buffer.
 // Therefore, we have to free the iteration argument %iterBuf before
 // "returning" %3.
 
 // CHECK-LABEL: func @loop_nested_if_alloc
 func @loop_nested_if_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>) -> memref<2xf32> {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
-      %4 = alloc() : memref<2xf32>
+      %4 = memref.alloc() : memref<2xf32>
       scf.yield %4 : memref<2xf32>
     } else {
       scf.yield %0 : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   return %1 : memref<2xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%arg3, %[[ALLOC1]])
 // CHECK-NEXT: %[[ALLOC2:.*]] = scf.for {{.*}} iter_args
 // CHECK-SAME: (%[[IALLOC:.*]] = %[[ALLOC1]]
-//      CHECK: dealloc %[[IALLOC]]
+//      CHECK: memref.dealloc %[[IALLOC]]
 //      CHECK: %[[ALLOC3:.*]] = scf.if
 
-//      CHECK: %[[ALLOC4:.*]] = alloc()
-// CHECK-NEXT: %[[ALLOC5:.*]] = alloc()
+//      CHECK: %[[ALLOC4:.*]] = memref.alloc()
+// CHECK-NEXT: %[[ALLOC5:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC4]], %[[ALLOC5]])
-// CHECK-NEXT: dealloc %[[ALLOC4]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC4]]
 // CHECK-NEXT: scf.yield %[[ALLOC5]]
 
-//      CHECK: %[[ALLOC6:.*]] = alloc()
+//      CHECK: %[[ALLOC6:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC0]], %[[ALLOC6]])
 // CHECK-NEXT: scf.yield %[[ALLOC6]]
 
-//      CHECK: %[[ALLOC7:.*]] = alloc()
+//      CHECK: %[[ALLOC7:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC3:.*]], %[[ALLOC7]])
-// CHECK-NEXT: dealloc %[[ALLOC3]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
 // CHECK-NEXT: scf.yield %[[ALLOC7]]
 
-//      CHECK: dealloc %[[ALLOC0]]
+//      CHECK: memref.dealloc %[[ALLOC0]]
 // CHECK-NEXT: return %[[ALLOC2]]
 
 // -----
 
 // Test Case: several nested structured control-flow loops with a deeply nested
 // buffer allocation inside an if operation.
 // Same behavior is an loop_nested_if_alloc: we have to insert deallocations
 // before each yield in all loops recursively.
 
 // CHECK-LABEL: func @loop_nested_alloc
 func @loop_nested_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
       %3 = scf.for %i3 = %lb to %ub step %step
         iter_args(%iterBuf3 = %iterBuf2) -> memref<2xf32> {
-        %4 = alloc() : memref<2xf32>
+        %4 = memref.alloc() : memref<2xf32>
         %5 = cmpi eq, %i, %ub : index
         %6 = scf.if %5 -> (memref<2xf32>) {
-          %7 = alloc() : memref<2xf32>
+          %7 = memref.alloc() : memref<2xf32>
           scf.yield %7 : memref<2xf32>
         } else {
           scf.yield %iterBuf3 : memref<2xf32>
         }
         scf.yield %6 : memref<2xf32>
       }
       scf.yield %3 : memref<2xf32>
     }
     scf.yield %2 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
-// CHECK-NEXT: dealloc %[[ALLOC0]]
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
+// CHECK-NEXT: memref.dealloc %[[ALLOC0]]
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%arg3, %[[ALLOC1]])
 // CHECK-NEXT: %[[VAL_7:.*]] = scf.for {{.*}} iter_args
 // CHECK-SAME: (%[[IALLOC0:.*]] = %[[ALLOC1]])
-//      CHECK: %[[ALLOC2:.*]] = alloc()
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[IALLOC0]], %[[ALLOC2]])
-// CHECK-NEXT: dealloc %[[IALLOC0]]
+// CHECK-NEXT: memref.dealloc %[[IALLOC0]]
 // CHECK-NEXT: %[[ALLOC3:.*]] = scf.for {{.*}} iter_args
 // CHECK-SAME: (%[[IALLOC1:.*]] = %[[ALLOC2]])
-//      CHECK: %[[ALLOC5:.*]] = alloc()
+//      CHECK: %[[ALLOC5:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[IALLOC1]], %[[ALLOC5]])
-// CHECK-NEXT: dealloc %[[IALLOC1]]
+// CHECK-NEXT: memref.dealloc %[[IALLOC1]]
 
 //      CHECK: %[[ALLOC6:.*]] = scf.for {{.*}} iter_args
 // CHECK-SAME: (%[[IALLOC2:.*]] = %[[ALLOC5]])
-//      CHECK: %[[ALLOC8:.*]] = alloc()
-// CHECK-NEXT: dealloc %[[ALLOC8]]
+//      CHECK: %[[ALLOC8:.*]] = memref.alloc()
+// CHECK-NEXT: memref.dealloc %[[ALLOC8]]
 //      CHECK: %[[ALLOC9:.*]] = scf.if
 
-//      CHECK: %[[ALLOC11:.*]] = alloc()
-// CHECK-NEXT: %[[ALLOC12:.*]] = alloc()
+//      CHECK: %[[ALLOC11:.*]] = memref.alloc()
+// CHECK-NEXT: %[[ALLOC12:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC11]], %[[ALLOC12]])
-// CHECK-NEXT: dealloc %[[ALLOC11]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC11]]
 // CHECK-NEXT: scf.yield %[[ALLOC12]]
 
-//      CHECK: %[[ALLOC13:.*]] = alloc()
+//      CHECK: %[[ALLOC13:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[IALLOC2]], %[[ALLOC13]])
 // CHECK-NEXT: scf.yield %[[ALLOC13]]
 
-//      CHECK: dealloc %[[IALLOC2]]
-// CHECK-NEXT: %[[ALLOC10:.*]] = alloc()
+//      CHECK: memref.dealloc %[[IALLOC2]]
+// CHECK-NEXT: %[[ALLOC10:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC9]], %[[ALLOC10]])
-// CHECK-NEXT: dealloc %[[ALLOC9]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC9]]
 // CHECK-NEXT: scf.yield %[[ALLOC10]]
 
-//      CHECK: %[[ALLOC7:.*]] = alloc()
+//      CHECK: %[[ALLOC7:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC6]], %[[ALLOC7]])
-// CHECK-NEXT: dealloc %[[ALLOC6]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC6]]
 // CHECK-NEXT: scf.yield %[[ALLOC7]]
 
-//      CHECK: %[[ALLOC4:.*]] = alloc()
+//      CHECK: %[[ALLOC4:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ALLOC3]], %[[ALLOC4]])
-// CHECK-NEXT: dealloc %[[ALLOC3]]
+// CHECK-NEXT: memref.dealloc %[[ALLOC3]]
 // CHECK-NEXT: scf.yield %[[ALLOC4]]
 
 //      CHECK: test.copy(%[[VAL_7]], %arg4)
-// CHECK-NEXT: dealloc %[[VAL_7]]
+// CHECK-NEXT: memref.dealloc %[[VAL_7]]
 
 // -----
 
 // Test Case: explicit control-flow loop with a dynamically allocated buffer.
 // The BufferDeallocation transformation should fail on this explicit
 // control-flow loop since they are not supported.
 
 // expected-error@+1 {{Structured control-flow loops are supported only}}
^loopHeader(%i : i32, %buff : memref<?xf32>):
   cond_br %lessThan,
     ^loopBody(%i, %buff : i32, memref<?xf32>),
     ^exit(%buff : memref<?xf32>)
 
 ^loopBody(%val : i32, %buff2: memref<?xf32>):
   %const1 = constant 1 : i32
   %inc = addi %val, %const1 : i32
   %size = std.index_cast %inc : i32 to index
-  %alloc1 = alloc(%size) : memref<?xf32>
+  %alloc1 = memref.alloc(%size) : memref<?xf32>
   br ^loopHeader(%inc, %alloc1 : i32, memref<?xf32>)
 
 ^exit(%buff3 : memref<?xf32>):
   test.copy(%buff3, %arg3) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // -----
func @do_loop_alloc(
   %arg2: memref<2xf32>,
   %arg3: memref<2xf32>) {
   %const0 = constant 0 : i32
   br ^loopBody(%const0, %arg2 : i32, memref<2xf32>)
 
 ^loopBody(%val : i32, %buff2: memref<2xf32>):
   %const1 = constant 1 : i32
   %inc = addi %val, %const1 : i32
-  %alloc1 = alloc() : memref<2xf32>
+  %alloc1 = memref.alloc() : memref<2xf32>
   br ^loopHeader(%inc, %alloc1 : i32, memref<2xf32>)
 
 ^loopHeader(%i : i32, %buff : memref<2xf32>):
   %lessThan = cmpi slt, %i, %arg1 : i32
   cond_br %lessThan,
     ^loopBody(%i, %buff : i32, memref<2xf32>),
     ^exit(%buff : memref<2xf32>)
 
 ^exit(%buff3 : memref<2xf32>):
   test.copy(%buff3, %arg3) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @assumingOp(
 func @assumingOp(
   %arg0: !shape.witness,
   %arg2: memref<2xf32>,
   %arg3: memref<2xf32>) {
   // Confirm the alloc will be dealloc'ed in the block.
   %1 = shape.assuming %arg0 -> memref<2xf32> {
-     %0 = alloc() : memref<2xf32>
+     %0 = memref.alloc() : memref<2xf32>
     shape.assuming_yield %arg2 : memref<2xf32>
   }
   // Confirm the alloc will be returned and dealloc'ed after its use.
   %3 = shape.assuming %arg0 -> memref<2xf32> {
-    %2 = alloc() : memref<2xf32>
+    %2 = memref.alloc() : memref<2xf32>
     shape.assuming_yield %2 : memref<2xf32>
   }
   test.copy(%3, %arg3) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-SAME: %[[ARG0:.*]]: !shape.witness,
 // CHECK-SAME: %[[ARG1:.*]]: {{.*}},
 // CHECK-SAME: %[[ARG2:.*]]: {{.*}}
 //      CHECK: %[[UNUSED_RESULT:.*]] = shape.assuming %[[ARG0]]
-// CHECK-NEXT:    %[[ALLOC0:.*]] = alloc()
-// CHECK-NEXT:    dealloc %[[ALLOC0]]
+// CHECK-NEXT:    %[[ALLOC0:.*]] = memref.alloc()
+// CHECK-NEXT:    memref.dealloc %[[ALLOC0]]
 // CHECK-NEXT:    shape.assuming_yield %[[ARG1]]
 //      CHECK: %[[ASSUMING_RESULT:.*]] = shape.assuming %[[ARG0]]
-// CHECK-NEXT:    %[[TMP_ALLOC:.*]] = alloc()
-// CHECK-NEXT:    %[[RETURNING_ALLOC:.*]] = alloc()
+// CHECK-NEXT:    %[[TMP_ALLOC:.*]] = memref.alloc()
+// CHECK-NEXT:    %[[RETURNING_ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT:    linalg.copy(%[[TMP_ALLOC]], %[[RETURNING_ALLOC]])
-// CHECK-NEXT:    dealloc %[[TMP_ALLOC]]
+// CHECK-NEXT:    memref.dealloc %[[TMP_ALLOC]]
 // CHECK-NEXT:    shape.assuming_yield %[[RETURNING_ALLOC]]
 //      CHECK: test.copy(%[[ASSUMING_RESULT:.*]], %[[ARG2]])
-// CHECK-NEXT: dealloc %[[ASSUMING_RESULT]]
+// CHECK-NEXT: memref.dealloc %[[ASSUMING_RESULT]]
 
 // -----
 
 // Test Case: The op "test.bar" does not implement the RegionBranchOpInterface.
 // This is not allowed in buffer deallocation.
 
 func @noRegionBranchOpInterface() {
 // expected-error@+1 {{All operations with attached regions need to implement the RegionBranchOpInterface.}}

mlir/test/Transforms/buffer-hoisting.mlir

 // the entry block.
 
 // CHECK-LABEL: func @condBranch
 func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: cond_br
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  bb1  bb2 <- Initial position of AllocOp
 //   \   /
 //    bb3
 // BufferHoisting expected behavior: It should not move the existing AllocOp
 // to any other block since the alloc has a dynamic dependency to block argument
 // %0 in bb2.
 
 // CHECK-LABEL: func @condBranchDynamicType
 func @condBranchDynamicType(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb3(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   br ^bb3(%1 : memref<?xf32>)
 ^bb3(%2: memref<?xf32>):
   test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb2
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case:
 //      bb0
 //     /    \
 //   bb1    bb2 <- Initial position of AllocOp
func @condBranchDynamicTypeNested(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb6(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   cond_br %arg0, ^bb3, ^bb4
 ^bb3:
   br ^bb5(%1 : memref<?xf32>)
 ^bb4:
   br ^bb5(%1 : memref<?xf32>)
 ^bb5(%2: memref<?xf32>):
   br ^bb6(%2 : memref<?xf32>)
 ^bb6(%3: memref<?xf32>):
   br ^bb7(%3 : memref<?xf32>)
 ^bb7(%4: memref<?xf32>):
   test.copy(%4, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb2
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  |    bb1 <- Initial position of AllocOp
 //   \   /
 //    bb2
 // BufferHoisting expected behavior: It should move the existing AllocOp to
 // the entry block.
 
 // CHECK-LABEL: func @criticalEdge
 func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb2(%0 : memref<2xf32>)
 ^bb2(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: cond_br
 
 // -----
 
 // Test Case:
 //    bb0 <- Initial position of the first AllocOp
 //   /   \
 //  bb1  bb2
 //   \   /
 //    bb3 <- Initial position of the second AllocOp
 // BufferHoisting expected behavior: It shouldn't move the AllocOps.
 
 // CHECK-LABEL: func @ifElse
 func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
-  %7 = alloc() : memref<2xf32>
+  %7 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%7: memref<2xf32>)
   test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 //      CHECK: br ^bb3
 //      CHECK: br ^bb3
 // CHECK-NEXT: ^bb3
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 //      CHECK: test.copy(%[[ALLOC1]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: No users for buffer in if-else CFG
 //    bb0 <- Initial position of AllocOp
 //   /   \
 //  bb1  bb2
 //   \   /
 //    bb3
 // BufferHoisting expected behavior: It shouldn't move the AllocOp.
 
 // CHECK-LABEL: func @ifElseNoUsers
 func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
   test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case:
 //      bb0 <- Initial position of the first AllocOp
 //     /    \
 //   bb1    bb2
 //    |     /  \
 //    |   bb3  bb4
 //    \     \  /
 //     \     /
 //       bb5 <- Initial position of the second AllocOp
 // BufferHoisting expected behavior: AllocOps shouldn't be moved.
 
 // CHECK-LABEL: func @ifElseNested
 func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
 ^bb3(%5: memref<2xf32>):
   br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
 ^bb4(%6: memref<2xf32>):
   br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
 ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
-  %9 = alloc() : memref<2xf32>
+  %9 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
   test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 //      CHECK: br ^bb5
 //      CHECK: br ^bb5
 //      CHECK: br ^bb5
 // CHECK-NEXT: ^bb5
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case: Dead operations in a single block.
 // BufferHoisting expected behavior: It shouldn't move the AllocOps.
 
 // CHECK-LABEL: func @redundantOperations
 func @redundantOperations(%arg0: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%0: memref<2xf32>) out(%1: memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case:
 //                                     bb0
 //                                    /   \
 // Initial pos of the 1st AllocOp -> bb1  bb2 <- Initial pos of the 2nd AllocOp
 //                                    \   /
 //                                     bb3
 // BufferHoisting expected behavior: Both AllocOps should be moved to the
 // entry block.
 
 // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
 func @moving_alloc_and_inserting_missing_dealloc(
   %cond: i1,
     %arg0: memref<2xf32>,
     %arg1: memref<2xf32>) {
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
   br ^exit(%0 : memref<2xf32>)
 ^bb2:
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
   br ^exit(%1 : memref<2xf32>)
 ^exit(%arg2: memref<2xf32>):
   test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %{{.*}} = alloc()
-// CHECK-NEXT: %{{.*}} = alloc()
+// CHECK-NEXT: %{{.*}} = memref.alloc()
+// CHECK-NEXT: %{{.*}} = memref.alloc()
 // CHECK-NEXT: cond_br
 
 // -----
 
 // Test Case: Invalid position of the DeallocOp. There is a user after
 // deallocation.
 //   bb0
 //  /   \
 // bb1  bb2 <- Initial position of AllocOp
 //  \   /
 //   bb3
 // BufferHoisting expected behavior: It should move the AllocOp to the entry
 // block.
 
 // CHECK-LABEL: func @moving_invalid_dealloc_op_complex
 func @moving_invalid_dealloc_op_complex(
   %cond: i1,
     %arg0: memref<2xf32>,
     %arg1: memref<2xf32>) {
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
   br ^exit(%arg0 : memref<2xf32>)
 ^bb2:
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
-  dealloc %1 : memref<2xf32>
+  memref.dealloc %1 : memref<2xf32>
   br ^exit(%1 : memref<2xf32>)
 ^exit(%arg2: memref<2xf32>):
   test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %{{.*}} = alloc()
+// CHECK-NEXT: %{{.*}} = memref.alloc()
 // CHECK-NEXT: cond_br
 
 // -----
 
 // Test Case: Nested regions - This test defines a BufferBasedOp inside the
 // region of a RegionBufferBasedOp.
 // BufferHoisting expected behavior: The AllocOp for the BufferBasedOp should
 // remain inside the region of the RegiobBufferBasedOp. The AllocOp of the
 // RegionBufferBasedOp should be moved to the entry block.
 
 // CHECK-LABEL: func @nested_regions_and_cond_branch
 func @nested_regions_and_cond_branch(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloc() : memref<2xf32>
+    %1 = memref.alloc() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
-// CHECK-NEXT:   %[[ALLOC0:.*]] = alloc()
+// CHECK-NEXT:   %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT:   cond_br
 //      CHECK:   test.region_buffer_based
-//      CHECK:     %[[ALLOC1:.*]] = alloc()
+//      CHECK:     %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT:     test.buffer_based
 
 // -----
 
 // Test Case: nested region control flow
 // The alloc position of %1 does not need to be changed and flows through
 // both if branches until it is finally returned.
 
 // CHECK-LABEL: func @nested_region_control_flow
 func @nested_region_control_flow(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %1 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %{{.*}} = scf.if
 //      CHECK: else
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%arg0, %arg1)
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%arg0, %arg1)
 
 // -----
 
 // Test Case: nested region control flow with a nested buffer allocation in a
 // divergent branch.
 // The alloc positions of %1 does not need to be changed. %3 is moved upwards.
 
 // CHECK-LABEL: func @nested_region_control_flow_div
 func @nested_region_control_flow_div(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %3 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%arg0, %arg1)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%arg0, %arg1)
 // CHECK-NEXT: %{{.*}} = scf.if
 
 // -----
 
 // Test Case: deeply nested region control flow with a nested buffer allocation
 // in a divergent branch.
 // The alloc position of %1 does not need to be changed. Allocs %4 and %5 are
 // moved upwards.
 
 // CHECK-LABEL: func @nested_region_control_flow_div_nested
 func @nested_region_control_flow_div_nested(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     %3 = scf.if %0 -> (memref<?x?xf32>) {
       scf.yield %1 : memref<?x?xf32>
     } else {
-      %4 = alloc(%arg0, %arg1) : memref<?x?xf32>
+      %4 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
       scf.yield %4 : memref<?x?xf32>
     }
     scf.yield %3 : memref<?x?xf32>
   } else {
-    %5 = alloc(%arg1, %arg1) : memref<?x?xf32>
+    %5 = memref.alloc(%arg1, %arg1) : memref<?x?xf32>
     scf.yield %5 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%arg0, %arg1)
-// CHECK-NEXT: %[[ALLOC2:.*]] = alloc(%arg1, %arg1)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%arg0, %arg1)
+// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc(%arg1, %arg1)
 // CHECK-NEXT: %{{.*}} = scf.if
 
 // -----
 
 // Test Case: nested region control flow within a region interface.
 // The alloc positions of %0 does not need to be changed.
 
 // CHECK-LABEL: func @inner_region_control_flow
 func @inner_region_control_flow(%arg0 : index) -> memref<?x?xf32> {
-  %0 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %1 = test.region_if %0 : memref<?x?xf32> -> (memref<?x?xf32>) then {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   } else {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   } join {
     ^bb0(%arg1 : memref<?x?xf32>):
       test.region_if_yield %arg1 : memref<?x?xf32>
   }
   return %1 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: {{.*}} test.region_if
 
 // -----
 
 // Test Case: nested region control flow within a region interface including an
 // allocation in a divergent branch.
 // The alloc positions of %0 does not need to be changed. %2 is moved upwards.
 
 // CHECK-LABEL: func @inner_region_control_flow_div
 func @inner_region_control_flow_div(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
-  %0 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %0 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %1 = test.region_if %0 : memref<?x?xf32> -> (memref<?x?xf32>) then {
     ^bb0(%arg2 : memref<?x?xf32>):
       test.region_if_yield %arg2 : memref<?x?xf32>
   } else {
     ^bb0(%arg2 : memref<?x?xf32>):
-      %2 = alloc(%arg0, %arg1) : memref<?x?xf32>
+      %2 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
       test.region_if_yield %2 : memref<?x?xf32>
   } join {
     ^bb0(%arg2 : memref<?x?xf32>):
       test.region_if_yield %arg2 : memref<?x?xf32>
   }
   return %1 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%arg0, %arg1)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%arg0, %arg1)
 // CHECK-NEXT: {{.*}} test.region_if
 
 // -----
 
 // Test Case: Alloca operations shouldn't be moved.
 
 // CHECK-LABEL: func @condBranchAlloca
 func @condBranchAlloca(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloca() : memref<2xf32>
+  %0 = memref.alloca() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb2
 //      CHECK: ^bb2
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case: Alloca operations shouldn't be moved. The alloc operation also
 // shouldn't be moved analogously to the ifElseNested test.
 
 // CHECK-LABEL: func @ifElseNestedAlloca
 func @ifElseNestedAlloca(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
-  %0 = alloca() : memref<2xf32>
+  %0 = memref.alloca() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
 ^bb3(%5: memref<2xf32>):
   br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
 ^bb4(%6: memref<2xf32>):
   br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
 ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
-  %9 = alloc() : memref<2xf32>
+  %9 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
   test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
 //      CHECK: ^bb5
 //      CHECK: ^bb5
 //      CHECK: ^bb5
 // CHECK-NEXT: ^bb5
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case: Alloca operations shouldn't be moved. The alloc operation should
 // be moved in the beginning analogous to the nestedRegionsAndCondBranch test.
 
 // CHECK-LABEL: func @nestedRegionsAndCondBranchAlloca
 func @nestedRegionsAndCondBranchAlloca(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloca() : memref<2xf32>
+    %1 = memref.alloca() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
-// CHECK-NEXT:   %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT:   %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT:   cond_br
 //      CHECK:   test.region_buffer_based
-//      CHECK:     %[[ALLOCA:.*]] = alloca()
+//      CHECK:     %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT:     test.buffer_based
 
 // -----
 
 // Test Case: structured control-flow loop using a nested alloc.
 // The alloc positions of %3 will be moved upwards.
 
 // CHECK-LABEL: func @loop_alloc
 func @loop_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
-    %3 = alloc() : memref<2xf32>
+    %3 = memref.alloc() : memref<2xf32>
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation using
 // a deeply nested buffer allocation.
 // The allocation %4 is not moved upwards.
 
 // CHECK-LABEL: func @loop_nested_if_alloc
 func @loop_nested_if_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>) -> memref<2xf32> {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
-      %4 = alloc() : memref<2xf32>
+      %4 = memref.alloc() : memref<2xf32>
       scf.yield %4 : memref<2xf32>
     } else {
       scf.yield %0 : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   return %1 : memref<2xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: several nested structured control-flow loops with a deeply nested
 // buffer allocation inside an if operation.
 // Same behavior is an loop_nested_if_alloc: The allocs are not moved upwards.
 
 // CHECK-LABEL: func @loop_nested_alloc
 func @loop_nested_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
       %3 = scf.for %i3 = %lb to %ub step %step
         iter_args(%iterBuf3 = %iterBuf2) -> memref<2xf32> {
-        %4 = alloc() : memref<2xf32>
+        %4 = memref.alloc() : memref<2xf32>
         %5 = cmpi eq, %i, %ub : index
         %6 = scf.if %5 -> (memref<2xf32>) {
-          %7 = alloc() : memref<2xf32>
+          %7 = memref.alloc() : memref<2xf32>
           scf.yield %7 : memref<2xf32>
         } else {
           scf.yield %iterBuf3 : memref<2xf32>
         }
         scf.yield %6 : memref<2xf32>
       }
       scf.yield %3 : memref<2xf32>
     }
     scf.yield %2 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc()
-//      CHECK: %[[ALLOC2:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc()
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc()
 
 // -----
 
 // CHECK-LABEL: func @loop_nested_alloc_dyn_dependency
 func @loop_nested_alloc_dyn_dependency(
   %lb: index,
   %ub: index,
   %step: index,
   %arg0: index,
   %buf: memref<?xf32>,
   %res: memref<?xf32>) {
-  %0 = alloc(%arg0) : memref<?xf32>
+  %0 = memref.alloc(%arg0) : memref<?xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<?xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<?xf32> {
       %3 = scf.for %i3 = %lb to %ub step %step
         iter_args(%iterBuf3 = %iterBuf2) -> memref<?xf32> {
         %5 = cmpi eq, %i, %ub : index
         %6 = scf.if %5 -> (memref<?xf32>) {
-          %7 = alloc(%i3) : memref<?xf32>
+          %7 = memref.alloc(%i3) : memref<?xf32>
           scf.yield %7 : memref<?xf32>
         } else {
           scf.yield %iterBuf3 : memref<?xf32>
         }
         scf.yield %6 : memref<?xf32>
       }
       scf.yield %3 : memref<?xf32>
     }
     scf.yield %0 : memref<?xf32>
   }
   test.copy(%1, %res) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc({{.*}})

mlir/test/Transforms/buffer-loop-hoisting.mlir

 // BufferLoopHoisting expected behavior: It should not move the AllocOp.
 
 // CHECK-LABEL: func @condBranch
 func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
-//      CHECK: %[[ALLOC:.*]] = alloc()
+//      CHECK: %[[ALLOC:.*]] = memref.alloc()
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  bb1  bb2 <- Initial position of AllocOp
 //   \   /
 //    bb3
 // BufferLoopHoisting expected behavior: It should not move the existing AllocOp
 // to any other block since the alloc has a dynamic dependency to block argument
 // %0 in bb2.
 
 // CHECK-LABEL: func @condBranchDynamicType
 func @condBranchDynamicType(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb3(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   br ^bb3(%1 : memref<?xf32>)
 ^bb3(%2: memref<?xf32>):
   test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb2
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 
 // -----
 
 // Test Case: Nested regions - This test defines a BufferBasedOp inside the
 // region of a RegionBufferBasedOp.
 // BufferLoopHoisting expected behavior: The AllocOp for the BufferBasedOp
 // should remain inside the region of the RegionBufferBasedOp. The AllocOp of
 // the RegionBufferBasedOp should not be moved during this pass.
 
 // CHECK-LABEL: func @nested_regions_and_cond_branch
 func @nested_regions_and_cond_branch(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloc() : memref<2xf32>
+    %1 = memref.alloc() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 // CHECK-NEXT:   cond_br
-//      CHECK:   %[[ALLOC0:.*]] = alloc()
+//      CHECK:   %[[ALLOC0:.*]] = memref.alloc()
 //      CHECK:   test.region_buffer_based
-//      CHECK:     %[[ALLOC1:.*]] = alloc()
+//      CHECK:     %[[ALLOC1:.*]] = memref.alloc()
 // CHECK-NEXT:     test.buffer_based
 
 // -----
 
 // Test Case: nested region control flow
 // The alloc position of %1 does not need to be changed and flows through
 // both if branches until it is finally returned.
 
 // CHECK-LABEL: func @nested_region_control_flow
 func @nested_region_control_flow(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %1 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %{{.*}} = scf.if
 //      CHECK: else
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc(%arg0, %arg1)
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc(%arg0, %arg1)
 
 // -----
 
 // Test Case: structured control-flow loop using a nested alloc.
 // The alloc positions of %3 should not be changed.
 
 // CHECK-LABEL: func @loop_alloc
 func @loop_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
-    %3 = alloc() : memref<2xf32>
+    %3 = memref.alloc() : memref<2xf32>
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation using
 // a deeply nested buffer allocation.
 // The allocation %4 should not be moved upwards due to a back-edge dependency.
 
 // CHECK-LABEL: func @loop_nested_if_alloc
 func @loop_nested_if_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>) -> memref<2xf32> {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
-      %4 = alloc() : memref<2xf32>
+      %4 = memref.alloc() : memref<2xf32>
       scf.yield %4 : memref<2xf32>
     } else {
       scf.yield %0 : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   return %1 : memref<2xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc()
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: several nested structured control-flow loops with deeply nested
 // buffer allocations inside an if operation.
 // Behavior: The allocs %0, %4 and %9 are moved upwards, while %7 and %8 stay
 // in their positions.
 
 // CHECK-LABEL: func @loop_nested_alloc
 func @loop_nested_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
       %3 = scf.for %i3 = %lb to %ub step %step
         iter_args(%iterBuf3 = %iterBuf2) -> memref<2xf32> {
-        %4 = alloc() : memref<2xf32>
+        %4 = memref.alloc() : memref<2xf32>
         %5 = cmpi eq, %i, %ub : index
         %6 = scf.if %5 -> (memref<2xf32>) {
-          %7 = alloc() : memref<2xf32>
-          %8 = alloc() : memref<2xf32>
+          %7 = memref.alloc() : memref<2xf32>
+          %8 = memref.alloc() : memref<2xf32>
           scf.yield %8 : memref<2xf32>
         } else {
           scf.yield %iterBuf3 : memref<2xf32>
         }
-        %9 = alloc() : memref<2xf32>
+        %9 = memref.alloc() : memref<2xf32>
         scf.yield %6 : memref<2xf32>
       }
       scf.yield %3 : memref<2xf32>
     }
     scf.yield %2 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc()
-// CHECK-NEXT: %[[ALLOC2:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc()
+// CHECK-NEXT: %[[ALLOC2:.*]] = memref.alloc()
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
 //      CHECK: {{.*}} = scf.if
-//      CHECK: %[[ALLOC3:.*]] = alloc()
-//      CHECK: %[[ALLOC4:.*]] = alloc()
+//      CHECK: %[[ALLOC3:.*]] = memref.alloc()
+//      CHECK: %[[ALLOC4:.*]] = memref.alloc()
 
 // -----
 
 // CHECK-LABEL: func @loop_nested_alloc_dyn_dependency
 func @loop_nested_alloc_dyn_dependency(
   %lb: index,
   %ub: index,
   %step: index,
   %arg0: index,
   %buf: memref<?xf32>,
   %res: memref<?xf32>) {
-  %0 = alloc(%arg0) : memref<?xf32>
+  %0 = memref.alloc(%arg0) : memref<?xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<?xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<?xf32> {
       %3 = scf.for %i3 = %lb to %ub step %step
         iter_args(%iterBuf3 = %iterBuf2) -> memref<?xf32> {
-        %4 = alloc(%i3) : memref<?xf32>
+        %4 = memref.alloc(%i3) : memref<?xf32>
         %5 = cmpi eq, %i, %ub : index
         %6 = scf.if %5 -> (memref<?xf32>) {
-          %7 = alloc(%i3) : memref<?xf32>
+          %7 = memref.alloc(%i3) : memref<?xf32>
           scf.yield %7 : memref<?xf32>
         } else {
           scf.yield %iterBuf3 : memref<?xf32>
         }
-        %8 = alloc(%i3) : memref<?xf32>
+        %8 = memref.alloc(%i3) : memref<?xf32>
         scf.yield %6 : memref<?xf32>
       }
       scf.yield %3 : memref<?xf32>
     }
     scf.yield %0 : memref<?xf32>
   }
   test.copy(%1, %res) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
 // CHECK-NEXT: {{.*}} = scf.for
-//      CHECK: %[[ALLOC1:.*]] = alloc({{.*}})
-//      CHECK: %[[ALLOC2:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC1:.*]] = memref.alloc({{.*}})
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc({{.*}})
 
 // -----
 
 // CHECK-LABEL: func @hoist_one_loop
 func @hoist_one_loop(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
-      %2 = alloc() : memref<2xf32>
+      %2 = memref.alloc() : memref<2xf32>
       scf.yield %0 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
 
 // -----
 
 // CHECK-LABEL: func @no_hoist_one_loop
 func @no_hoist_one_loop(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
   %0 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
-      %1 = alloc() : memref<2xf32>
+      %1 = memref.alloc() : memref<2xf32>
       scf.yield %1 : memref<2xf32>
   }
   test.copy(%0, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 //      CHECK: {{.*}} = scf.for
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 
 // -----
 
 // CHECK-LABEL: func @hoist_multiple_loop
 func @hoist_multiple_loop(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
-        %3 = alloc() : memref<2xf32>
+        %3 = memref.alloc() : memref<2xf32>
         scf.yield %0 : memref<2xf32>
     }
     scf.yield %0 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
 
 // -----
 
 // CHECK-LABEL: func @no_hoist_one_loop_conditional
 func @no_hoist_one_loop_conditional(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
   %0 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
       %1 = cmpi eq, %i, %ub : index
       %2 = scf.if %1 -> (memref<2xf32>) {
-        %3 = alloc() : memref<2xf32>
+        %3 = memref.alloc() : memref<2xf32>
         scf.yield %3 : memref<2xf32>
       } else {
         scf.yield %iterBuf : memref<2xf32>
       }
     scf.yield %2 : memref<2xf32>
   }
   test.copy(%0, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 //      CHECK: {{.*}} = scf.for
 //      CHECK: {{.*}} = scf.if
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 
 // -----
 
 // CHECK-LABEL: func @hoist_one_loop_conditional
 func @hoist_one_loop_conditional(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = cmpi eq, %lb, %ub : index
   %2 = scf.if %1 -> (memref<2xf32>) {
     %3 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
-      %4 = alloc() : memref<2xf32>
+      %4 = memref.alloc() : memref<2xf32>
       scf.yield %0 : memref<2xf32>
     }
     scf.yield %0 : memref<2xf32>
   }
   else
   {
     scf.yield %0 : memref<2xf32>
   }
   test.copy(%2, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 //      CHECK: {{.*}} = scf.if
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 //      CHECK: {{.*}} = scf.for
 
 // -----
 
 // CHECK-LABEL: func @no_hoist_one_loop_dependency
 func @no_hoist_one_loop_dependency(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
-      %2 = alloc(%i) : memref<?xf32>
+      %2 = memref.alloc(%i) : memref<?xf32>
       scf.yield %0 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc({{.*}})
 
 // -----
 
 // CHECK-LABEL: func @partial_hoist_multiple_loop_dependency
 func @partial_hoist_multiple_loop_dependency(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = scf.for %i2 = %lb to %ub step %step
       iter_args(%iterBuf2 = %iterBuf) -> memref<2xf32> {
-        %3 = alloc(%i) : memref<?xf32>
+        %3 = memref.alloc(%i) : memref<?xf32>
         scf.yield %0 : memref<2xf32>
     }
     scf.yield %0 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc({{.*}})
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for
-// CHECK-NEXT: %[[ALLOC1:.*]] = alloc({{.*}})
+// CHECK-NEXT: %[[ALLOC1:.*]] = memref.alloc({{.*}})
 // CHECK-NEXT: {{.*}} = scf.for

mlir/test/Transforms/buffer-results-to-out-params.mlir

 func private @mixed_result_attrs() -> (memref<1xf32>, memref<2xf32> {test.some_attr}, memref<3xf32>)
 
 // -----
 
 // CHECK-LABEL: func private @callee(memref<1xf32>)
 func private @callee() -> memref<1xf32>
 
 // CHECK-LABEL:   func @call_basic() {
-// CHECK:           %[[OUTPARAM:.*]] = alloc() : memref<1xf32>
+// CHECK:           %[[OUTPARAM:.*]] = memref.alloc() : memref<1xf32>
 // CHECK:           call @callee(%[[OUTPARAM]]) : (memref<1xf32>) -> ()
 // CHECK:           "test.sink"(%[[OUTPARAM]]) : (memref<1xf32>) -> ()
 // CHECK:           return
 // CHECK:         }
 func @call_basic() {
   %0 = call @callee() : () -> memref<1xf32>
   "test.sink"(%0) : (memref<1xf32>) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: func private @callee(memref<1xf32>, memref<2xf32>)
 func private @callee() -> (memref<1xf32>, memref<2xf32>)
 
 // CHECK-LABEL:   func @call_multiple_result() {
-// CHECK:           %[[RESULT0:.*]] = alloc() : memref<1xf32>
-// CHECK:           %[[RESULT1:.*]] = alloc() : memref<2xf32>
+// CHECK:           %[[RESULT0:.*]] = memref.alloc() : memref<1xf32>
+// CHECK:           %[[RESULT1:.*]] = memref.alloc() : memref<2xf32>
 // CHECK:           call @callee(%[[RESULT0]], %[[RESULT1]]) : (memref<1xf32>, memref<2xf32>) -> ()
 // CHECK:           "test.sink"(%[[RESULT0]], %[[RESULT1]]) : (memref<1xf32>, memref<2xf32>) -> ()
 // CHECK:         }
 func @call_multiple_result() {
   %0, %1 = call @callee() : () -> (memref<1xf32>, memref<2xf32>)
   "test.sink"(%0, %1) : (memref<1xf32>, memref<2xf32>) -> ()
 }
 
 // -----
 
 // CHECK-LABEL: func private @callee(memref<1xf32>) -> (i1, i32)
 func private @callee() -> (i1, memref<1xf32>, i32)
 
 // CHECK-LABEL:   func @call_non_memref_result() {
-// CHECK:           %[[RESULT0:.*]] = alloc() : memref<1xf32>
+// CHECK:           %[[RESULT0:.*]] = memref.alloc() : memref<1xf32>
 // CHECK:           %[[NON_MEMREF_RESULTS:.*]]:2 = call @callee(%[[RESULT0]]) : (memref<1xf32>) -> (i1, i32)
 // CHECK:           "test.sink"(%[[NON_MEMREF_RESULTS]]#0, %[[RESULT0]], %[[NON_MEMREF_RESULTS]]#1) : (i1, memref<1xf32>, i32) -> ()
 // CHECK:         }
 func @call_non_memref_result() {
   %0, %1, %2 = call @callee() : () -> (i1, memref<1xf32>, i32)
   "test.sink"(%0, %1, %2) : (i1, memref<1xf32>, i32) -> ()
 }
 

mlir/test/Transforms/canonicalize-block-merge.mlir

func @mismatch_operand_types(%arg0 : i1, %arg1 : memref<i32>, %arg2 : memref<i1>) {
   %c0_i32 = constant 0 : i32
   %true = constant true
   br ^bb1
 
 ^bb1:
   cond_br %arg0, ^bb2, ^bb3
 
 ^bb2:
-  // CHECK: store %{{.*}}, %{{.*}} : memref<i32>
-  store %c0_i32, %arg1[] : memref<i32>
+  // CHECK: memref.store %{{.*}}, %{{.*}} : memref<i32>
+  memref.store %c0_i32, %arg1[] : memref<i32>
   br ^bb1
 
 ^bb3:
-  // CHECK: store %{{.*}}, %{{.*}} : memref<i1>
-  store %true, %arg2[] : memref<i1>
+  // CHECK: memref.store %{{.*}}, %{{.*}} : memref<i1>
+  memref.store %true, %arg2[] : memref<i1>
   br ^bb1
 }
 
 // Check that it is illegal to merge blocks containing an operand
 // with an external user. Incorrectly performing the optimization
 // anyways will result in print(merged, merged) rather than
 // distinct operands.
 func private @print(%arg0: i32, %arg1: i32)

mlir/test/Transforms/canonicalize.mlir

func @trivial_dce(%arg0: tensor<8x4xf32>) {
   %0 = dim %arg0, %c1 : tensor<8x4xf32>
   // CHECK-NEXT: return
   return
 }
 
 // CHECK-LABEL: func @load_dce
 func @load_dce(%arg0: index) {
   %c4 = constant 4 : index
-  %a = alloc(%c4) : memref<?xf32>
+  %a = memref.alloc(%c4) : memref<?xf32>
   %2 = load %a[%arg0] : memref<?xf32>
-  dealloc %a: memref<?xf32>
+  memref.dealloc %a: memref<?xf32>
   // CHECK-NEXT: return
   return
 }
 
 // CHECK-LABEL: func @addi_zero
 func @addi_zero(%arg0: i32) -> i32 {
   // CHECK-NEXT: return %arg0
   %c0_i32 = constant 0 : i32
func @xor_self_tensor(%arg0: tensor<4x5xi32>) -> tensor<4x5xi32> {
   //CHECK-NEXT: %cst = constant dense<0> : tensor<4x5xi32>
   %1 = xor %arg0, %arg0 : tensor<4x5xi32>
   //CHECK-NEXT: return %cst
   return %1 : tensor<4x5xi32>
 }
 
 // CHECK-LABEL: func @memref_cast_folding
 func @memref_cast_folding(%arg0: memref<4 x f32>, %arg1: f32) -> (f32, f32) {
-  %0 = memref_cast %arg0 : memref<4xf32> to memref<?xf32>
+  %0 = memref.cast %arg0 : memref<4xf32> to memref<?xf32>
   // CHECK-NEXT: %c0 = constant 0 : index
   %c0 = constant 0 : index
   %dim = dim %0, %c0 : memref<? x f32>
 
   // CHECK-NEXT: affine.load %arg0[3]
   %1 = affine.load %0[%dim - 1] : memref<?xf32>
 
-  // CHECK-NEXT: store %arg1, %arg0[%c0] : memref<4xf32>
-  store %arg1, %0[%c0] : memref<?xf32>
+  // CHECK-NEXT: memref.store %arg1, %arg0[%c0] : memref<4xf32>
+  memref.store %arg1, %0[%c0] : memref<?xf32>
 
   // CHECK-NEXT: %{{.*}} = load %arg0[%c0] : memref<4xf32>
   %2 = load %0[%c0] : memref<?xf32>
 
-  // CHECK-NEXT: dealloc %arg0 : memref<4xf32>
-  dealloc %0: memref<?xf32>
+  // CHECK-NEXT: memref.dealloc %arg0 : memref<4xf32>
+  memref.dealloc %0: memref<?xf32>
 
   // CHECK-NEXT: return %{{.*}}
   return %1, %2 : f32, f32
 }
 
 // CHECK-LABEL: @fold_memref_cast_in_memref_cast
 // CHECK-SAME: (%[[ARG0:.*]]: memref<42x42xf64>)
 func @fold_memref_cast_in_memref_cast(%0: memref<42x42xf64>) {
-  // CHECK: %[[folded:.*]] = memref_cast %[[ARG0]] : memref<42x42xf64> to memref<?x?xf64>
-  %4 = memref_cast %0 : memref<42x42xf64> to memref<?x42xf64>
-  // CHECK-NOT: memref_cast
-  %5 = memref_cast %4 : memref<?x42xf64> to memref<?x?xf64>
+  // CHECK: %[[folded:.*]] = memref.cast %[[ARG0]] : memref<42x42xf64> to memref<?x?xf64>
+  %4 = memref.cast %0 : memref<42x42xf64> to memref<?x42xf64>
+  // CHECK-NOT: memref.cast
+  %5 = memref.cast %4 : memref<?x42xf64> to memref<?x?xf64>
   // CHECK: "test.user"(%[[folded]])
   "test.user"(%5) : (memref<?x?xf64>) -> ()
   return
 }
 
 // CHECK-LABEL: @fold_memref_cast_chain
 // CHECK-SAME: (%[[ARG0:.*]]: memref<42x42xf64>)
 func @fold_memref_cast_chain(%0: memref<42x42xf64>) {
-  // CHECK-NOT: memref_cast
-  %4 = memref_cast %0 : memref<42x42xf64> to memref<?x42xf64>
-  %5 = memref_cast %4 : memref<?x42xf64> to memref<42x42xf64>
+  // CHECK-NOT: memref.cast
+  %4 = memref.cast %0 : memref<42x42xf64> to memref<?x42xf64>
+  %5 = memref.cast %4 : memref<?x42xf64> to memref<42x42xf64>
   // CHECK: "test.user"(%[[ARG0]])
   "test.user"(%5) : (memref<42x42xf64>) -> ()
   return
 }
 
 // CHECK-LABEL: func @alloc_const_fold
 func @alloc_const_fold() -> memref<?xf32> {
-  // CHECK-NEXT: %0 = alloc() : memref<4xf32>
+  // CHECK-NEXT: %0 = memref.alloc() : memref<4xf32>
   %c4 = constant 4 : index
-  %a = alloc(%c4) : memref<?xf32>
+  %a = memref.alloc(%c4) : memref<?xf32>
 
-  // CHECK-NEXT: %1 = memref_cast %0 : memref<4xf32> to memref<?xf32>
+  // CHECK-NEXT: %1 = memref.cast %0 : memref<4xf32> to memref<?xf32>
   // CHECK-NEXT: return %1 : memref<?xf32>
   return %a : memref<?xf32>
 }
 
 // CHECK-LABEL: func @dead_alloc_fold
 func @dead_alloc_fold() {
   // CHECK-NEXT: return
   %c4 = constant 4 : index
-  %a = alloc(%c4) : memref<?xf32>
+  %a = memref.alloc(%c4) : memref<?xf32>
   return
 }
 
 // CHECK-LABEL: func @dead_dealloc_fold
 func @dead_dealloc_fold() {
   // CHECK-NEXT: return
-  %a = alloc() : memref<4xf32>
-  dealloc %a: memref<4xf32>
+  %a = memref.alloc() : memref<4xf32>
+  memref.dealloc %a: memref<4xf32>
   return
 }
 
 // CHECK-LABEL: func @dead_dealloc_fold_multi_use
 func @dead_dealloc_fold_multi_use(%cond : i1) {
   // CHECK-NEXT: return
-  %a = alloc() : memref<4xf32>
+  %a = memref.alloc() : memref<4xf32>
   cond_br %cond, ^bb1, ^bb2
 
 ^bb1:
-  dealloc %a: memref<4xf32>
+  memref.dealloc %a: memref<4xf32>
   return
 
 ^bb2:
-  dealloc %a: memref<4xf32>
+  memref.dealloc %a: memref<4xf32>
   return
 }
 
 // CHECK-LABEL: func @dead_block_elim
 func @dead_block_elim() {
   // CHECK-NOT: ^bb
   func @nested() {
     return

 func @dyn_shape_fold(%L : index, %M : index) -> (memref<? x ? x i32>, memref<? x ? x f32>, memref<4 x ? x 8 x ? x ? x f32>) {
   // CHECK: %c0 = constant 0 : index
   %zero = constant 0 : index
   // The constants below disappear after they propagate into shapes.
   %nine = constant 9 : index
   %N = constant 1024 : index
   %K = constant 512 : index
 
-  // CHECK-NEXT: alloc(%arg0) : memref<?x1024xf32>
-  %a = alloc(%L, %N) : memref<? x ? x f32>
+  // CHECK-NEXT: memref.alloc(%arg0) : memref<?x1024xf32>
+  %a = memref.alloc(%L, %N) : memref<? x ? x f32>
 
-  // CHECK-NEXT: alloc(%arg1) : memref<4x1024x8x512x?xf32>
-  %b = alloc(%N, %K, %M) : memref<4 x ? x 8 x ? x ? x f32>
+  // CHECK-NEXT: memref.alloc(%arg1) : memref<4x1024x8x512x?xf32>
+  %b = memref.alloc(%N, %K, %M) : memref<4 x ? x 8 x ? x ? x f32>
 
-  // CHECK-NEXT: alloc() : memref<512x1024xi32>
-  %c = alloc(%K, %N) : memref<? x ? x i32>
+  // CHECK-NEXT: memref.alloc() : memref<512x1024xi32>
+  %c = memref.alloc(%K, %N) : memref<? x ? x i32>
 
-  // CHECK: alloc() : memref<9x9xf32>
-  %d = alloc(%nine, %nine) : memref<? x ? x f32>
+  // CHECK: memref.alloc() : memref<9x9xf32>
+  %d = memref.alloc(%nine, %nine) : memref<? x ? x f32>
 
-  // CHECK: alloca(%arg1) : memref<4x1024x8x512x?xf32>
-  %e = alloca(%N, %K, %M) : memref<4 x ? x 8 x ? x ? x f32>
+  // CHECK: memref.alloca(%arg1) : memref<4x1024x8x512x?xf32>
+  %e = memref.alloca(%N, %K, %M) : memref<4 x ? x 8 x ? x ? x f32>
 
   // CHECK: affine.for
   affine.for %i = 0 to %L {
     // CHECK-NEXT: affine.for
     affine.for %j = 0 to 10 {
       // CHECK-NEXT: load %0[%arg2, %arg3] : memref<?x1024xf32>
-      // CHECK-NEXT: store %{{.*}}, %1[%c0, %c0, %arg2, %arg3, %c0] : memref<4x1024x8x512x?xf32>
+      // CHECK-NEXT: memref.store %{{.*}}, %1[%c0, %c0, %arg2, %arg3, %c0] : memref<4x1024x8x512x?xf32>
       %v = load %a[%i, %j] : memref<?x?xf32>
-      store %v, %b[%zero, %zero, %i, %j, %zero] : memref<4x?x8x?x?xf32>
+      memref.store %v, %b[%zero, %zero, %i, %j, %zero] : memref<4x?x8x?x?xf32>
     }
   }
 
   return %c, %d, %e : memref<? x ? x i32>, memref<? x ? x f32>, memref<4 x ? x 8 x ? x ? x f32>
 }
 
 #map1 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 #map2 = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s2 + d1 * s1 + d2 + s0)>
 #map3 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 
 // CHECK-LABEL: func @dim_op_fold(
 // CHECK-SAME: %[[ARG0:[a-z0-9]*]]: index
 // CHECK-SAME: %[[ARG1:[a-z0-9]*]]: index
 // CHECK-SAME: %[[ARG2:[a-z0-9]*]]: index
 // CHECK-SAME: %[[BUF:[a-z0-9]*]]: memref<?xi8>
 func @dim_op_fold(%arg0: index, %arg1: index, %arg2: index, %BUF: memref<?xi8>, %M : index, %N : index, %K : index) {
 // CHECK-SAME: [[M:arg[0-9]+]]: index
 // CHECK-SAME: [[N:arg[0-9]+]]: index
 // CHECK-SAME: [[K:arg[0-9]+]]: index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
-  %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
-  %1 = alloc(%arg1, %arg2) : memref<?x8x?xf32>
+  %0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
+  %1 = memref.alloc(%arg1, %arg2) : memref<?x8x?xf32>
   %2 = dim %1, %c2 : memref<?x8x?xf32>
   affine.for %arg3 = 0 to %2 {
-    %3 = alloc(%arg0) : memref<?xi8>
+    %3 = memref.alloc(%arg0) : memref<?xi8>
     %ub = dim %3, %c0 : memref<?xi8>
     affine.for %arg4 = 0 to %ub {
       %s = dim %0, %c0 : memref<?x?xf32>
-      %v = std.view %3[%c0][%arg4, %s] : memref<?xi8> to memref<?x?xf32>
+      %v = memref.view %3[%c0][%arg4, %s] : memref<?xi8> to memref<?x?xf32>
       %sv = subview %0[%c0, %c0][%s,%arg4][%c1,%c1] : memref<?x?xf32> to memref<?x?xf32, #map1>
       %l = dim %v, %c1 : memref<?x?xf32>
       %u = dim %sv, %c0 : memref<?x?xf32, #map1>
       affine.for %arg5 = %l to %u {
         "foo"() : () -> ()
       }
       %sv2 = subview %0[0, 0][17, %arg4][1, 1] : memref<?x?xf32> to memref<17x?xf32, #map3>
       %l2 = dim %v, %c1 : memref<?x?xf32>
// CHECK-SAME: [[K:arg[0-9]+]]: index
   // CHECK-NEXT:       "foo"() : () -> ()
   // CHECK-NEXT:     }
   // CHECK-NEXT:     scf.for %[[KK:.*]] = %[[ARG0]] to %[[J]] step %{{.*}} {
   // CHECK-NEXT:       "foo"() : () -> ()
   // CHECK-NEXT:     }
   // CHECK-NEXT:   }
   // CHECK-NEXT: }
 
-  %A = view %BUF[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
-  %B = view %BUF[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
-  %C = view %BUF[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  %A = memref.view %BUF[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
+  %B = memref.view %BUF[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
+  %C = memref.view %BUF[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
 
   %M_ = dim %A, %c0 : memref<?x?xf32>
   %K_ = dim %A, %c1 : memref<?x?xf32>
   %N_ = dim %C, %c1 : memref<?x?xf32>
   scf.for %i = %c0 to %M_ step %c1 {
     scf.for %j = %c0 to %N_ step %c1 {
       scf.for %k = %c0 to %K_ step %c1 {
       }
func @merge_constants() -> (index, index) {
   return %0, %1: index, index
 }
 
 // CHECK-LABEL: func @hoist_constant
 func @hoist_constant(%arg0: memref<8xi32>) {
   // CHECK-NEXT: %c42_i32 = constant 42 : i32
   // CHECK-NEXT: affine.for %arg1 = 0 to 8 {
   affine.for %arg1 = 0 to 8 {
-    // CHECK-NEXT: store %c42_i32, %arg0[%arg1]
+    // CHECK-NEXT: memref.store %c42_i32, %arg0[%arg1]
     %c42_i32 = constant 42 : i32
-    store %c42_i32, %arg0[%arg1] : memref<8xi32>
+    memref.store %c42_i32, %arg0[%arg1] : memref<8xi32>
   }
   return
 }
 
 // CHECK-LABEL: func @const_fold_propagate
 func @const_fold_propagate() -> memref<?x?xf32> {
   %VT_i = constant 512 : index
 
   %VT_i_s = affine.apply affine_map<(d0) -> (d0 floordiv  8)> (%VT_i)
   %VT_k_l = affine.apply affine_map<(d0) -> (d0 floordiv  16)> (%VT_i)
 
-  // CHECK: = alloc() : memref<64x32xf32>
-  %Av = alloc(%VT_i_s, %VT_k_l) : memref<?x?xf32>
+  // CHECK: = memref.alloc() : memref<64x32xf32>
+  %Av = memref.alloc(%VT_i_s, %VT_k_l) : memref<?x?xf32>
   return %Av : memref<?x?xf32>
 }
 
 // CHECK-LABEL: func @indirect_call_folding
 func @indirect_target() {
   return
 }
 
// CHECK-NEXT:  %c2 = constant 2 : index
   %15 = select %8, %13, %14 : index
   return %7, %15 : index, index
 }
 
 // Checks that NOP casts are removed.
 // CHECK-LABEL: cast_values
 func @cast_values(%arg0: memref<?xi32>) -> memref<2xi32> {
   // NOP cast
-  %1 = memref_cast %arg0 : memref<?xi32> to memref<?xi32>
-  // CHECK-NEXT: %[[RET:.*]] = memref_cast %arg0 : memref<?xi32> to memref<2xi32>
-  %3 = memref_cast %1 : memref<?xi32> to memref<2xi32>
+  %1 = memref.cast %arg0 : memref<?xi32> to memref<?xi32>
+  // CHECK-NEXT: %[[RET:.*]] = memref.cast %arg0 : memref<?xi32> to memref<2xi32>
+  %3 = memref.cast %1 : memref<?xi32> to memref<2xi32>
   // NOP cast
-  %5 = memref_cast %3 : memref<2xi32> to memref<2xi32>
+  %5 = memref.cast %3 : memref<2xi32> to memref<2xi32>
   // CHECK-NEXT: return %[[RET]] : memref<2xi32>
   return %5 : memref<2xi32>
 }
 
 // -----
 
 // CHECK-LABEL: func @view
 func @view(%arg0 : index) -> (f32, f32, f32, f32) {
   // CHECK: %[[C15:.*]] = constant 15 : index
-  // CHECK: %[[ALLOC_MEM:.*]] = alloc() : memref<2048xi8>
-  %0 = alloc() : memref<2048xi8>
+  // CHECK: %[[ALLOC_MEM:.*]] = memref.alloc() : memref<2048xi8>
+  %0 = memref.alloc() : memref<2048xi8>
   %c0 = constant 0 : index
   %c7 = constant 7 : index
   %c11 = constant 11 : index
   %c15 = constant 15 : index
 
   // Test: fold constant sizes.
-  // CHECK: std.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<7x11xf32>
-  %1 = view %0[%c15][%c7, %c11] : memref<2048xi8> to memref<?x?xf32>
+  // CHECK: memref.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<7x11xf32>
+  %1 = memref.view %0[%c15][%c7, %c11] : memref<2048xi8> to memref<?x?xf32>
   %r0 = load %1[%c0, %c0] : memref<?x?xf32>
 
   // Test: fold one constant size.
-  // CHECK: std.view %[[ALLOC_MEM]][%[[C15]]][%arg0, %arg0] : memref<2048xi8> to memref<?x?x7xf32>
-  %2 = view %0[%c15][%arg0, %arg0, %c7] : memref<2048xi8> to memref<?x?x?xf32>
+  // CHECK: memref.view %[[ALLOC_MEM]][%[[C15]]][%arg0, %arg0] : memref<2048xi8> to memref<?x?x7xf32>
+  %2 = memref.view %0[%c15][%arg0, %arg0, %c7] : memref<2048xi8> to memref<?x?x?xf32>
   %r1 = load %2[%c0, %c0, %c0] : memref<?x?x?xf32>
 
   // Test: preserve an existing static size.
-  // CHECK: std.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<7x4xf32>
-  %3 = view %0[%c15][%c7] : memref<2048xi8> to memref<?x4xf32>
+  // CHECK: memref.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<7x4xf32>
+  %3 = memref.view %0[%c15][%c7] : memref<2048xi8> to memref<?x4xf32>
   %r2 = load %3[%c0, %c0] : memref<?x4xf32>
 
-  // Test: folding static alloc and memref_cast into a view.
-  // CHECK: std.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<15x7xf32>
-  %4 = memref_cast %0 : memref<2048xi8> to memref<?xi8>
-  %5 = view %4[%c15][%c15, %c7] : memref<?xi8> to memref<?x?xf32>
+  // Test: folding static alloc and memref.cast into a view.
+  // CHECK memref.view %[[ALLOC_MEM]][%[[C15]]][] : memref<2048xi8> to memref<15x7xf32>
+  %4 = memref.cast %0 : memref<2048xi8> to memref<?xi8>
+  %5 = memref.view %4[%c15][%c15, %c7] : memref<?xi8> to memref<?x?xf32>
   %r3 = load %5[%c0, %c0] : memref<?x?xf32>
   return %r0, %r1, %r2, %r3 : f32, f32, f32, f32
 }
 
 // -----
 
 // CHECK-DAG: #[[$BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
 // CHECK-DAG: #[[$SUBVIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 64 + s0 + d1 * 4 + d2)>
func @subview(%arg0 : index, %arg1 : index) -> (index, index) {
   // CHECK: %[[C7:.*]] = constant 7 : index
   %c7 = constant 7 : index
   // Folded but reappears after subview folding into dim.
   // CHECK: %[[C11:.*]] = constant 11 : index
   %c11 = constant 11 : index
   // CHECK-NOT: constant 15 : index
   %c15 = constant 15 : index
 
-  // CHECK: %[[ALLOC0:.*]] = alloc()
-  %0 = alloc() : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]>
+  // CHECK: %[[ALLOC0:.*]] = memref.alloc()
+  %0 = memref.alloc() : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]>
 
   // Test: subview with constant base memref and constant operands is folded.
   // Note that the subview uses the base memrefs layout map because it used
   // zero offset and unit stride arguments.
   // CHECK: subview %[[ALLOC0]][0, 0, 0] [7, 11, 2] [1, 1, 1] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<7x11x2xf32, #[[$BASE_MAP0]]>
   %1 = subview %0[%c0, %c0, %c0] [%c7, %c11, %c2] [%c1, %c1, %c1]
     : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]> to
       memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
   %v0 = load %1[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
   // Test: subview with one dynamic operand can also be folded.
   // CHECK: subview %[[ALLOC0]][0, %[[ARG0]], 0] [7, 11, 15] [1, 1, 1] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<7x11x15xf32, #[[$SUBVIEW_MAP0]]>
   %2 = subview %0[%c0, %arg0, %c0] [%c7, %c11, %c15] [%c1, %c1, %c1]
     : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]> to
       memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
-  store %v0, %2[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
+  memref.store %v0, %2[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
-  // CHECK: %[[ALLOC1:.*]] = alloc(%[[ARG0]])
-  %3 = alloc(%arg0) : memref<?x16x4xf32, offset : 0, strides : [64, 4, 1]>
+  // CHECK: %[[ALLOC1:.*]] = memref.alloc(%[[ARG0]])
+  %3 = memref.alloc(%arg0) : memref<?x16x4xf32, offset : 0, strides : [64, 4, 1]>
   // Test: subview with constant operands but dynamic base memref is folded as long as the strides and offset of the base memref are static.
   // CHECK: subview %[[ALLOC1]][0, 0, 0] [7, 11, 15] [1, 1, 1] :
   // CHECK-SAME: memref<?x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<7x11x15xf32, #[[$BASE_MAP0]]>
   %4 = subview %3[%c0, %c0, %c0] [%c7, %c11, %c15] [%c1, %c1, %c1]
     : memref<?x16x4xf32, offset : 0, strides : [64, 4, 1]> to
       memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
-  store %v0, %4[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
+  memref.store %v0, %4[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
   // Test: subview offset operands are folded correctly w.r.t. base strides.
   // CHECK: subview %[[ALLOC0]][1, 2, 7] [7, 11, 2] [1, 1, 1] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]> to
   // CHECK-SAME: memref<7x11x2xf32, #[[$SUBVIEW_MAP1]]>
   %5 = subview %0[%c1, %c2, %c7] [%c7, %c11, %c2] [%c1, %c1, %c1]
     : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]> to
       memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
-  store %v0, %5[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
+  memref.store %v0, %5[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
   // Test: subview stride operands are folded correctly w.r.t. base strides.
   // CHECK: subview %[[ALLOC0]][0, 0, 0] [7, 11, 2] [2, 7, 11] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]>
   // CHECK-SAME: to memref<7x11x2xf32, #[[$SUBVIEW_MAP2]]>
   %6 = subview %0[%c0, %c0, %c0] [%c7, %c11, %c2] [%c2, %c7, %c11]
     : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]> to
       memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
-  store %v0, %6[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
+  memref.store %v0, %6[%c0, %c0, %c0] : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
   // Test: subview shape are folded, but offsets and strides are not even if base memref is static
   // CHECK: subview %[[ALLOC0]][%[[ARG0]], %[[ARG0]], %[[ARG0]]] [7, 11, 2] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]> to
   // CHECK-SAME: memref<7x11x2xf32, #[[$SUBVIEW_MAP3]]>
   %10 = subview %0[%arg0, %arg0, %arg0] [%c7, %c11, %c2] [%arg1, %arg1, %arg1] :
     memref<8x16x4xf32, offset:0, strides:[64, 4, 1]> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %10[%arg1, %arg1, %arg1] :
+  memref.store %v0, %10[%arg1, %arg1, %arg1] :
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
   // Test: subview strides are folded, but offsets and shape are not even if base memref is static
   // CHECK: subview %[[ALLOC0]][%[[ARG0]], %[[ARG0]], %[[ARG0]]] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] [2, 7, 11] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]> to
   // CHECK-SAME: memref<?x?x?xf32, #[[$SUBVIEW_MAP4]]
   %11 = subview %0[%arg0, %arg0, %arg0] [%arg1, %arg1, %arg1] [%c2, %c7, %c11] :
     memref<8x16x4xf32, offset:0, strides:[64, 4, 1]> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %11[%arg0, %arg0, %arg0] :
+  memref.store %v0, %11[%arg0, %arg0, %arg0] :
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
   // Test: subview offsets are folded, but strides and shape are not even if base memref is static
   // CHECK: subview %[[ALLOC0]][1, 2, 7] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] [%[[ARG0]], %[[ARG0]], %[[ARG0]]] :
   // CHECK-SAME: memref<8x16x4xf32, #[[$BASE_MAP0]]> to
   // CHECK-SAME: memref<?x?x?xf32, #[[$SUBVIEW_MAP5]]
   %13 = subview %0[%c1, %c2, %c7] [%arg1, %arg1, %arg1] [%arg0, %arg0, %arg0] :
     memref<8x16x4xf32, offset:0, strides:[64, 4, 1]> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %13[%arg1, %arg1, %arg1] :
+  memref.store %v0, %13[%arg1, %arg1, %arg1] :
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
-  // CHECK: %[[ALLOC2:.*]] = alloc(%[[ARG0]], %[[ARG0]], %[[ARG1]])
-  %14 = alloc(%arg0, %arg0, %arg1) : memref<?x?x?xf32>
+  // CHECK: %[[ALLOC2:.*]] = memref.alloc(%[[ARG0]], %[[ARG0]], %[[ARG1]])
+  %14 = memref.alloc(%arg0, %arg0, %arg1) : memref<?x?x?xf32>
   // Test: subview shape are folded, even if base memref is not static
   // CHECK: subview %[[ALLOC2]][%[[ARG0]], %[[ARG0]], %[[ARG0]]] [7, 11, 2] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] :
   // CHECK-SAME: memref<?x?x?xf32> to
   // CHECK-SAME: memref<7x11x2xf32, #[[$SUBVIEW_MAP3]]>
   %15 = subview %14[%arg0, %arg0, %arg0] [%c7, %c11, %c2] [%arg1, %arg1, %arg1] :
     memref<?x?x?xf32> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %15[%arg1, %arg1, %arg1] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
+  memref.store %v0, %15[%arg1, %arg1, %arg1] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
   // TEST: subview strides are folded, in the type only the most minor stride is folded.
   // CHECK: subview %[[ALLOC2]][%[[ARG0]], %[[ARG0]], %[[ARG0]]] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] [2, 2, 2] :
   // CHECK-SAME: memref<?x?x?xf32> to
   // CHECK-SAME: memref<?x?x?xf32, #[[$SUBVIEW_MAP6]]
   %16 = subview %14[%arg0, %arg0, %arg0] [%arg1, %arg1, %arg1] [%c2, %c2, %c2] :
     memref<?x?x?xf32> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %16[%arg0, %arg0, %arg0] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
+  memref.store %v0, %16[%arg0, %arg0, %arg0] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
   // TEST: subview offsets are folded but the type offset remains dynamic, when the base memref is not static
   // CHECK: subview %[[ALLOC2]][1, 1, 1] [%[[ARG0]], %[[ARG0]], %[[ARG0]]] [%[[ARG1]], %[[ARG1]], %[[ARG1]]] :
   // CHECK-SAME: memref<?x?x?xf32> to
   // CHECK-SAME: memref<?x?x?xf32, #[[$SUBVIEW_MAP3]]
   %17 = subview %14[%c1, %c1, %c1] [%arg0, %arg0, %arg0] [%arg1, %arg1, %arg1] :
     memref<?x?x?xf32> to
     memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
-  store %v0, %17[%arg0, %arg0, %arg0] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
+  memref.store %v0, %17[%arg0, %arg0, %arg0] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
-  // CHECK: %[[ALLOC3:.*]] = alloc() : memref<12x4xf32>
-  %18 = alloc() : memref<12x4xf32>
+  // CHECK: %[[ALLOC3:.*]] = memref.alloc() : memref<12x4xf32>
+  %18 = memref.alloc() : memref<12x4xf32>
   %c4 = constant 4 : index
 
   // TEST: subview strides are maintained when sizes are folded
   // CHECK: subview %[[ALLOC3]][%arg1, %arg1] [2, 4] [1, 1] :
   // CHECK-SAME: memref<12x4xf32> to
   // CHECK-SAME: memref<2x4xf32, #[[$SUBVIEW_MAP7]]>
   %19 = subview %18[%arg1, %arg1] [%c2, %c4] [1, 1] :
     memref<12x4xf32> to
     memref<?x?xf32, offset: ?, strides:[4, 1]>
-  store %v0, %19[%arg1, %arg1] : memref<?x?xf32, offset: ?, strides:[4, 1]>
+  memref.store %v0, %19[%arg1, %arg1] : memref<?x?xf32, offset: ?, strides:[4, 1]>
 
   // TEST: subview strides and sizes are maintained when offsets are folded
   // CHECK: subview %[[ALLOC3]][2, 4] [12, 4] [1, 1] :
   // CHECK-SAME: memref<12x4xf32> to
   // CHECK-SAME: memref<12x4xf32, #[[$SUBVIEW_MAP8]]>
   %20 = subview %18[%c2, %c4] [12, 4] [1, 1] :
     memref<12x4xf32> to
     memref<12x4xf32, offset: ?, strides:[4, 1]>
-  store %v0, %20[%arg1, %arg1] : memref<12x4xf32, offset: ?, strides:[4, 1]>
+  memref.store %v0, %20[%arg1, %arg1] : memref<12x4xf32, offset: ?, strides:[4, 1]>
 
   // Test: dim on subview is rewritten to size operand.
   %7 = dim %4, %c0 : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
   %8 = dim %4, %c1 : memref<?x?x?xf32, offset : ?, strides : [?, ?, ?]>
 
   // CHECK: return %[[C7]], %[[C11]]
   return %7, %8 : index, index
 }
func @tensor_ceildivi_signed_by_one(%arg0: tensor<4x5xi32>) -> tensor<4x5xi32> {
   // CHECK: return %[[ARG]]
   return %res : tensor<4x5xi32>
 }
 
 // -----
 
 // CHECK-LABEL: func @memref_cast_folding_subview
 func @memref_cast_folding_subview(%arg0: memref<4x5xf32>, %i: index) -> (memref<?x?xf32, offset:? , strides: [?, ?]>) {
-  %0 = memref_cast %arg0 : memref<4x5xf32> to memref<?x?xf32>
+  %0 = memref.cast %arg0 : memref<4x5xf32> to memref<?x?xf32>
   // CHECK-NEXT: subview %{{.*}}: memref<4x5xf32>
   %1 = subview %0[%i, %i][%i, %i][%i, %i]: memref<?x?xf32> to memref<?x?xf32, offset:? , strides: [?, ?]>
   // CHECK-NEXT: return %{{.*}}
   return %1: memref<?x?xf32, offset:? , strides: [?, ?]>
 }
 
 // -----
 
 // CHECK-DAG: #[[$map0:.*]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 // CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
 
 // CHECK-LABEL: func @memref_cast_folding_subview_static(
 func @memref_cast_folding_subview_static(%V: memref<16x16xf32>, %a: index, %b: index)
   -> memref<3x4xf32, offset:?, strides:[?, 1]>
 {
-  %0 = memref_cast %V : memref<16x16xf32> to memref<?x?xf32>
+  %0 = memref.cast %V : memref<16x16xf32> to memref<?x?xf32>
   %1 = subview %0[0, 0][3, 4][1, 1] : memref<?x?xf32> to memref<3x4xf32, offset:?, strides:[?, 1]>
 
   // CHECK:  subview{{.*}}: memref<16x16xf32> to memref<3x4xf32, #[[$map0]]>
-  // CHECK:  memref_cast{{.*}}: memref<3x4xf32, #[[$map0]]> to memref<3x4xf32, #[[$map1]]>
   return %1: memref<3x4xf32, offset:?, strides:[?, 1]>
 }
 
 // -----
 
 // CHECK-LABEL: func @subtensor
 // CHECK-SAME: %[[ARG0:[0-9a-z]*]]: index, %[[ARG1:[0-9a-z]*]]: index
-func @subtensor(%t: tensor<8x16x4xf32>, %arg0 : index, %arg1 : index) 
-  -> tensor<?x?x?xf32> 
+func @subtensor(%t: tensor<8x16x4xf32>, %arg0 : index, %arg1 : index)
+  -> tensor<?x?x?xf32>
 {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c7 = constant 7 : index
   %c11 = constant 11 : index
 
   // CHECK: subtensor %{{.*}}[0, 0, 0] [7, 11, 2] [1, 1, 1] :

mlir/test/Transforms/constant-fold.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -test-constant-fold | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: @affine_for
 // CHECK-SAME: [[ARG:%[a-zA-Z0-9]+]]
 func @affine_for(%p : memref<f32>) {
   // CHECK: [[C:%.+]] = constant 6.{{0*}}e+00 : f32
   affine.for %arg1 = 0 to 128 {
     affine.for %arg2 = 0 to 8 { // CHECK: affine.for %{{.*}} = 0 to 8 {
       %0 = constant 4.5 : f32
       %1 = constant 1.5 : f32
 
       %2 = addf %0, %1 : f32
 
-      // CHECK-NEXT: store [[C]], [[ARG]][]
-      store %2, %p[] : memref<f32>
+      // CHECK-NEXT: memref.store [[C]], [[ARG]][]
+      memref.store %2, %p[] : memref<f32>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @simple_addf

mlir/test/Transforms/copy-removal.mlir

 // RUN: mlir-opt -copy-removal -split-input-file %s | FileCheck %s
 
 // All linalg copies except the linalg.copy(%1, %9) must be removed since the
 // defining operation of %1 and its DeallocOp have been defined in another block.
 
 // CHECK-LABEL: func @nested_region_control_flow_div_nested
 func @nested_region_control_flow_div_nested(%arg0: index, %arg1: index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   // CHECK: %{{.*}} = scf.if
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     // CHECK: %[[PERCENT3:.*]] = scf.if
     %3 = scf.if %0 -> (memref<?x?xf32>) {
       %c0_0 = constant 0 : index
       %7 = dim %1, %c0_0 : memref<?x?xf32>
       %c1_1 = constant 1 : index
       %8 = dim %1, %c1_1 : memref<?x?xf32>
-      %9 = alloc(%7, %8) : memref<?x?xf32>
+      %9 = memref.alloc(%7, %8) : memref<?x?xf32>
       // CHECK: linalg.copy({{.*}}, %[[PERCENT9:.*]])
       linalg.copy(%1, %9) : memref<?x?xf32>, memref<?x?xf32>
       // CHECK: scf.yield %[[PERCENT9]]
       scf.yield %9 : memref<?x?xf32>
     } else {
-      // CHECK: %[[PERCENT7:.*]] = alloc
-      %7 = alloc(%arg0, %arg1) : memref<?x?xf32>
+      // CHECK: %[[PERCENT7:.*]] = memref.alloc
+      %7 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
       %c0_0 = constant 0 : index
       %8 = dim %7, %c0_0 : memref<?x?xf32>
       %c1_1 = constant 1 : index
       %9 = dim %7, %c1_1 : memref<?x?xf32>
-      // CHECK-NOT: %{{.*}} = alloc
+      // CHECK-NOT: %{{.*}} = memref.alloc
       // CHECK-NOT: linalg.copy(%[[PERCENT7]], %{{.*}})
-      // CHECK-NOT: dealloc %[[PERCENT7]]
-      %10 = alloc(%8, %9) : memref<?x?xf32>
+      // CHECK-NOT: memref.dealloc %[[PERCENT7]]
+      %10 = memref.alloc(%8, %9) : memref<?x?xf32>
       linalg.copy(%7, %10) : memref<?x?xf32>, memref<?x?xf32>
-      dealloc %7 : memref<?x?xf32>
+      memref.dealloc %7 : memref<?x?xf32>
       // CHECK: scf.yield %[[PERCENT7]]
       scf.yield %10 : memref<?x?xf32>
     }
     %c0 = constant 0 : index
     %4 = dim %3, %c0 : memref<?x?xf32>
     %c1 = constant 1 : index
     %5 = dim %3, %c1 : memref<?x?xf32>
-    // CHECK-NOT: %{{.*}} = alloc
+    // CHECK-NOT: %{{.*}} = memref.alloc
     // CHECK-NOT: linalg.copy(%[[PERCENT3]], %{{.*}})
-    // CHECK-NOT: dealloc %[[PERCENT3]]
-    %6 = alloc(%4, %5) : memref<?x?xf32>
+    // CHECK-NOT: memref.dealloc %[[PERCENT3]]
+    %6 = memref.alloc(%4, %5) : memref<?x?xf32>
     linalg.copy(%3, %6) : memref<?x?xf32>, memref<?x?xf32>
-    dealloc %3 : memref<?x?xf32>
+    memref.dealloc %3 : memref<?x?xf32>
     // CHECK: scf.yield %[[PERCENT3]]
     scf.yield %6 : memref<?x?xf32>
   } else {
-    // CHECK: %[[PERCENT3:.*]] = alloc
-    %3 = alloc(%arg1, %arg1) : memref<?x?xf32>
+    // CHECK: %[[PERCENT3:.*]] = memref.alloc
+    %3 = memref.alloc(%arg1, %arg1) : memref<?x?xf32>
     %c0 = constant 0 : index
     %4 = dim %3, %c0 : memref<?x?xf32>
     %c1 = constant 1 : index
     %5 = dim %3, %c1 : memref<?x?xf32>
-    // CHECK-NOT: %{{.*}} = alloc
+    // CHECK-NOT: %{{.*}} = memref.alloc
     // CHECK-NOT: linalg.copy(%[[PERCENT3]], %{{.*}})
-    // CHECK-NOT: dealloc %[[PERCENT3]]
-    %6 = alloc(%4, %5) : memref<?x?xf32>
+    // CHECK-NOT: memref.dealloc %[[PERCENT3]]
+    %6 = memref.alloc(%4, %5) : memref<?x?xf32>
     linalg.copy(%3, %6) : memref<?x?xf32>, memref<?x?xf32>
-    dealloc %3 : memref<?x?xf32>
+    memref.dealloc %3 : memref<?x?xf32>
     // CHECK: scf.yield %[[PERCENT3]]
     scf.yield %6 : memref<?x?xf32>
   }
-  dealloc %1 : memref<?x?xf32>
+  memref.dealloc %1 : memref<?x?xf32>
   return %2 : memref<?x?xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @simple_test
 func @simple_test() -> memref<5xf32> {
-  %temp = alloc() : memref<5xf32>
-  %ret = alloc() : memref<5xf32>
+  %temp = memref.alloc() : memref<5xf32>
+  %ret = memref.alloc() : memref<5xf32>
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   return %temp : memref<5xf32>
 }
 // CHECK-SAME: () -> memref<5xf32>
-// CHECK-NEXT: %[[ret:.*]] = alloc()
+// CHECK-NEXT: %[[ret:.*]] = memref.alloc()
 // CHECK-NOT: linalg.copy(%[[ret]], %{{.*}})
-// CHECK-NOT: dealloc %[[ret]]
+// CHECK-NOT: memref.dealloc %[[ret]]
 // CHECK: return %[[ret]]
 
 // -----
 
 // It is legal to remove the copy operation that %ret has a usage before the copy
 // operation. The allocation of %temp and the deallocation of %ret should be also
 // removed.
 
 // CHECK-LABEL: func @test_with_ret_usage_before_copy
 func @test_with_ret_usage_before_copy() -> memref<5xf32> {
-  %ret = alloc() : memref<5xf32>
-  %temp = alloc() : memref<5xf32>
+  %ret = memref.alloc() : memref<5xf32>
+  %temp = memref.alloc() : memref<5xf32>
   %c0 = constant 0 : index
   %dimension = dim %ret, %c0 : memref<5xf32>
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   return %temp : memref<5xf32>
 }
-// CHECK-NEXT: %[[ret:.*]] = alloc()
-// CHECK-NOT: %{{.*}} = alloc
+// CHECK-NEXT: %[[ret:.*]] = memref.alloc()
+// CHECK-NOT: %{{.*}} = memref.alloc
 // CHECK-NEXT: %{{.*}} = constant
 // CHECK-NEXT: %[[DIM:.*]] = dim %[[ret]]
 // CHECK-NOT: linalg.copy(%[[ret]], %{{.*}})
-// CHECK-NOT: dealloc %[[ret]]
+// CHECK-NOT: memref.dealloc %[[ret]]
 // CHECK: return %[[ret]]
 
 // -----
 
 // It is illegal to remove a copy operation that %ret has a usage after copy
 // operation.
 
 // CHECK-LABEL: func @test_with_ret_usage_after_copy
 func @test_with_ret_usage_after_copy() -> memref<5xf32> {
-  %ret = alloc() : memref<5xf32>
-  %temp = alloc() : memref<5xf32>
+  %ret = memref.alloc() : memref<5xf32>
+  %temp = memref.alloc() : memref<5xf32>
   // CHECK: linalg.copy
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
   %c0 = constant 0 : index
   %dimension = dim %ret, %c0 : memref<5xf32>
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   return %temp : memref<5xf32>
 }
 
 // -----
 
 // It is illegal to remove a copy operation that %temp has a usage before copy
 // operation.
 
 // CHECK-LABEL: func @test_with_temp_usage_before_copy
 func @test_with_temp_usage_before_copy() -> memref<5xf32> {
-  %ret = alloc() : memref<5xf32>
-  %temp = alloc() : memref<5xf32>
+  %ret = memref.alloc() : memref<5xf32>
+  %temp = memref.alloc() : memref<5xf32>
   %c0 = constant 0 : index
   %dimension = dim %temp, %c0 : memref<5xf32>
   // CHECK: linalg.copy
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   return %temp : memref<5xf32>
 }
 
 // -----
 
 // It is legal to remove the copy operation that %temp has a usage after the copy
 // operation. The allocation of %temp and the deallocation of %ret could be also
 // removed.
 
 // However the following pattern is not handled by copy removal.
-//   %from = alloc()
-//   %to = alloc()
+//   %from = memref.alloc()
+//   %to = memref.alloc()
 //   copy(%from, %to)
 //   read_from(%from) + write_to(%something_else)
-//   dealloc(%from)
+//   memref.dealloc(%from)
 //   return %to
 // In particular, linalg.generic is a memoryEffectOp between copy and dealloc.
 // Since no alias analysis is performed and no distinction is made between reads
 // and writes, the linalg.generic with effects blocks copy removal.
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @test_with_temp_usage_after_copy
 func @test_with_temp_usage_after_copy() -> memref<5xf32> {
-  %ret = alloc() : memref<5xf32>
-  %res = alloc() : memref<5xf32>
-  %temp = alloc() : memref<5xf32>
+  %ret = memref.alloc() : memref<5xf32>
+  %res = memref.alloc() : memref<5xf32>
+  %temp = memref.alloc() : memref<5xf32>
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
   linalg.generic {
     indexing_maps = [#map0, #map0],
     iterator_types = ["parallel"]}
     ins(%temp : memref<5xf32>)
    outs(%res : memref<5xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
     %tmp1 = math.exp %gen1_arg0 : f32
     linalg.yield %tmp1 : f32
   }
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   return %temp : memref<5xf32>
 }
-// CHECK-NEXT: %[[ret:.*]] = alloc()
-// CHECK-NEXT: %[[res:.*]] = alloc()
-// CHECK-NEXT: %[[temp:.*]] = alloc()
+// CHECK-NEXT: %[[ret:.*]] = memref.alloc()
+// CHECK-NEXT: %[[res:.*]] = memref.alloc()
+// CHECK-NEXT: %[[temp:.*]] = memref.alloc()
 // CHECK-NEXT: linalg.copy(%[[ret]], %[[temp]])
 // CHECK-NEXT: linalg.generic
-//      CHECK: dealloc %[[ret]]
+//      CHECK: memref.dealloc %[[ret]]
 //      CHECK: return %[[temp]]
 
 // -----
 
 // CHECK-LABEL: func @make_allocation
 func @make_allocation() -> memref<5xf32> {
-  %mem = alloc() : memref<5xf32>
+  %mem = memref.alloc() : memref<5xf32>
   return %mem : memref<5xf32>
 }
 
 // CHECK-LABEL: func @test_with_function_call
 func @test_with_function_call() -> memref<5xf32> {
   // CHECK-NEXT: %[[ret:.*]] = call @make_allocation() : () -> memref<5xf32>
   %ret = call @make_allocation() : () -> (memref<5xf32>)
-  // CHECK-NOT: %{{.*}} = alloc
+  // CHECK-NOT: %{{.*}} = memref.alloc
   // CHECK-NOT: linalg.copy(%[[ret]], %{{.*}})
-  // CHECK-NOT: dealloc %[[ret]]
-  %temp = alloc() : memref<5xf32>
+  // CHECK-NOT: memref.dealloc %[[ret]]
+  %temp = memref.alloc() : memref<5xf32>
   linalg.copy(%ret, %temp) : memref<5xf32>, memref<5xf32>
-  dealloc %ret : memref<5xf32>
+  memref.dealloc %ret : memref<5xf32>
   // CHECK: return %[[ret]]
   return %temp : memref<5xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @multiple_deallocs_in_different_blocks
 func @multiple_deallocs_in_different_blocks(%cond : i1) -> memref<5xf32> {
-  // CHECK-NEXT: %[[PERCENT0:.*]] = alloc()
-  %0 = alloc() : memref<5xf32>
+  // CHECK-NEXT: %[[PERCENT0:.*]] = memref.alloc()
+  %0 = memref.alloc() : memref<5xf32>
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
-  dealloc %0 : memref<5xf32>
+  memref.dealloc %0 : memref<5xf32>
   // CHECK: br ^[[BB3:.*]](%[[PERCENT0]]
   br ^bb3(%0 : memref<5xf32>)
 ^bb2:
-  // CHECK-NOT: %{{.*}} = alloc
+  // CHECK-NOT: %{{.*}} = memref.alloc
   // CHECK-NOT: linalg.copy(%[[PERCENT0]], %{{.*}})
-  // CHECK-NOT: dealloc %[[PERCENT0]]
-  %temp = alloc() : memref<5xf32>
+  // CHECK-NOT: memref.dealloc %[[PERCENT0]]
+  %temp = memref.alloc() : memref<5xf32>
   linalg.copy(%0, %temp) : memref<5xf32>, memref<5xf32>
-  dealloc %0 : memref<5xf32>
+  memref.dealloc %0 : memref<5xf32>
   // CHECK: br ^[[BB3]](%[[PERCENT0]]
   br ^bb3(%temp : memref<5xf32>)
 ^bb3(%res : memref<5xf32>):
   return %res : memref<5xf32>
 }
 
 // -----
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @test_ReuseCopyTargetAsSource
 func @test_ReuseCopyTargetAsSource(%arg0: memref<2xf32>, %result: memref<2xf32>){
   // CHECK-SAME: (%[[ARG0:.*]]: memref<2xf32>, %[[RES:.*]]: memref<2xf32>)
-  // CHECK-NOT: %{{.*}} = alloc
-  %temp = alloc() : memref<2xf32>
+  // CHECK-NOT: %{{.*}} = memref.alloc
+  %temp = memref.alloc() : memref<2xf32>
   // CHECK-NEXT: linalg.generic
   // CHECK-SAME: ins(%[[ARG0]]{{.*}}outs(%[[RES]]
   // CHECK-NOT: linalg.copy(%{{.*}}, %[[RES]])
-  // CHECK-NOT: dealloc %{{.*}}
+  // CHECK-NOT: memref.dealloc %{{.*}}
   linalg.generic {
     indexing_maps = [#map0, #map0],
     iterator_types = ["parallel"]}
     ins(%arg0 : memref<2xf32>)
    outs(%temp : memref<2xf32>) {
   ^bb0(%gen2_arg0: f32, %gen2_arg1: f32):
     %tmp2 = math.exp %gen2_arg0 : f32
     linalg.yield %tmp2 : f32
   }
   linalg.copy(%temp, %result) : memref<2xf32>, memref<2xf32>
-  dealloc %temp : memref<2xf32>
+  memref.dealloc %temp : memref<2xf32>
   // CHECK: return
   return
 }
 
 // -----
 
 // Copy operation must not be removed since an operation writes to %to value
 // before copy.
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @test_ReuseCopyTargetAsSource
 func @test_ReuseCopyTargetAsSource(%arg0: memref<2xf32>){
-  %to = alloc() : memref<2xf32>
-  %temp = alloc() : memref<2xf32>
+  %to = memref.alloc() : memref<2xf32>
+  %temp = memref.alloc() : memref<2xf32>
   linalg.generic {
     indexing_maps = [#map0, #map0],
     iterator_types = ["parallel"]}
     ins(%arg0 : memref<2xf32>)
    outs(%temp : memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
     %tmp1 = math.exp %gen1_arg0 : f32
     linalg.yield %tmp1 : f32
   }
   linalg.generic {
     indexing_maps = [#map0, #map0],
     iterator_types = ["parallel"]}
     ins(%arg0 : memref<2xf32>)
    outs(%to : memref<2xf32>) {
   ^bb0(%gen2_arg0: f32, %gen2_arg1: f32):
     %tmp2 = math.exp %gen2_arg0 : f32
     linalg.yield %tmp2 : f32
   }
   // CHECK: linalg.copy
   linalg.copy(%temp, %to) : memref<2xf32>, memref<2xf32>
-  dealloc %temp : memref<2xf32>
+  memref.dealloc %temp : memref<2xf32>
   return
 }
 
 // -----
 
 // The only redundant copy is linalg.copy(%4, %5)
 
 // CHECK-LABEL: func @loop_alloc
 func @loop_alloc(%arg0: index, %arg1: index, %arg2: index, %arg3: memref<2xf32>, %arg4: memref<2xf32>) {
-  // CHECK: %{{.*}} = alloc()
-  %0 = alloc() : memref<2xf32>
-  dealloc %0 : memref<2xf32>
-  // CHECK: %{{.*}} = alloc()
-  %1 = alloc() : memref<2xf32>
+  // CHECK: %{{.*}} = memref.alloc()
+  %0 = memref.alloc() : memref<2xf32>
+  memref.dealloc %0 : memref<2xf32>
+  // CHECK: %{{.*}} = memref.alloc()
+  %1 = memref.alloc() : memref<2xf32>
   // CHECK: linalg.copy
   linalg.copy(%arg3, %1) : memref<2xf32>, memref<2xf32>
   %2 = scf.for %arg5 = %arg0 to %arg1 step %arg2 iter_args(%arg6 = %1) -> (memref<2xf32>) {
     %3 = cmpi eq, %arg5, %arg1 : index
-    // CHECK: dealloc
-    dealloc %arg6 : memref<2xf32>
-    // CHECK: %[[PERCENT4:.*]] = alloc()
-    %4 = alloc() : memref<2xf32>
-    // CHECK-NOT: alloc
+    // CHECK: memref.dealloc
+    memref.dealloc %arg6 : memref<2xf32>
+    // CHECK: %[[PERCENT4:.*]] = memref.alloc()
+    %4 = memref.alloc() : memref<2xf32>
+    // CHECK-NOT: memref.alloc
     // CHECK-NOT: linalg.copy
-    // CHECK-NOT: dealloc
-    %5 = alloc() : memref<2xf32>
+    // CHECK-NOT: memref.dealloc
+    %5 = memref.alloc() : memref<2xf32>
     linalg.copy(%4, %5) : memref<2xf32>, memref<2xf32>
-    dealloc %4 : memref<2xf32>
-    // CHECK: %[[PERCENT6:.*]] = alloc()
-    %6 = alloc() : memref<2xf32>
+    memref.dealloc %4 : memref<2xf32>
+    // CHECK: %[[PERCENT6:.*]] = memref.alloc()
+    %6 = memref.alloc() : memref<2xf32>
     // CHECK: linalg.copy(%[[PERCENT4]], %[[PERCENT6]])
     linalg.copy(%5, %6) : memref<2xf32>, memref<2xf32>
     scf.yield %6 : memref<2xf32>
   }
   // CHECK: linalg.copy
   linalg.copy(%2, %arg4) : memref<2xf32>, memref<2xf32>
-  dealloc %2 : memref<2xf32>
+  memref.dealloc %2 : memref<2xf32>
   return
 }
 
 // -----
 
 // The linalg.copy operation can be removed in addition to alloc and dealloc
 // operations. All uses of %0 is then replaced with %arg2.
 
 // CHECK-LABEL: func @check_with_affine_dialect
 func @check_with_affine_dialect(%arg0: memref<4xf32>, %arg1: memref<4xf32>, %arg2: memref<4xf32>) {
   // CHECK-SAME: (%[[ARG0:.*]]: memref<4xf32>, %[[ARG1:.*]]: memref<4xf32>, %[[RES:.*]]: memref<4xf32>)
-  // CHECK-NOT: alloc
-  %0 = alloc() : memref<4xf32>
+  // CHECK-NOT: memref.alloc
+  %0 = memref.alloc() : memref<4xf32>
   affine.for %arg3 = 0 to 4 {
     %5 = affine.load %arg0[%arg3] : memref<4xf32>
     %6 = affine.load %arg1[%arg3] : memref<4xf32>
     %7 = cmpf ogt, %5, %6 : f32
     // CHECK: %[[SELECT_RES:.*]] = select
     %8 = select %7, %5, %6 : f32
     // CHECK-NEXT: affine.store %[[SELECT_RES]], %[[RES]]
     affine.store %8, %0[%arg3] : memref<4xf32>
   }
   // CHECK-NOT: linalg.copy
   // CHECK-NOT: dealloc
   linalg.copy(%0, %arg2) : memref<4xf32>, memref<4xf32>
-  dealloc %0 : memref<4xf32>
+  memref.dealloc %0 : memref<4xf32>
   //CHECK: return
   return
 }

mlir/test/Transforms/cse.mlir

^bb0(%a : index, %b : index):
 
   // CHECK-NEXT: return %0, %1, %1 : i1, i1, i1
   return %0, %1, %2 : i1, i1, i1
 }
 
 /// Check that operations with side effects are not eliminated.
 // CHECK-LABEL: @side_effect
 func @side_effect() -> (memref<2x1xf32>, memref<2x1xf32>) {
-  // CHECK: %0 = alloc() : memref<2x1xf32>
-  %0 = alloc() : memref<2x1xf32>
+  // CHECK: %0 = memref.alloc() : memref<2x1xf32>
+  %0 = memref.alloc() : memref<2x1xf32>
 
-  // CHECK-NEXT: %1 = alloc() : memref<2x1xf32>
-  %1 = alloc() : memref<2x1xf32>
+  // CHECK-NEXT: %1 = memref.alloc() : memref<2x1xf32>
+  %1 = memref.alloc() : memref<2x1xf32>
 
   // CHECK-NEXT: return %0, %1 : memref<2x1xf32>, memref<2x1xf32>
   return %0, %1 : memref<2x1xf32>, memref<2x1xf32>
 }
 
 /// Check that operation definitions are properly propagated down the dominance
 /// tree.
 // CHECK-LABEL: @down_propagate_for

mlir/test/Transforms/loop-fusion-dependence-check.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -test-loop-fusion -test-loop-fusion-dependence-check -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: func @cannot_fuse_would_create_cycle() {
 func @cannot_fuse_would_create_cycle() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   // Set up the following dependences:
   // 1) loop0 -> loop1 on memref '%a'
   // 2) loop0 -> loop2 on memref '%b'
   // 3) loop1 -> loop2 on memref '%c'
 
func @cannot_fuse_would_create_cycle() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @can_fuse_rar_dependence() {
 func @can_fuse_rar_dependence() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   // Set up the following dependences:
   // Make dependence from 0 to 1 on '%a' read-after-read.
   // 1) loop0 -> loop1 on memref '%a'
   // 2) loop0 -> loop2 on memref '%b'
   // 3) loop1 -> loop2 on memref '%c'
func @can_fuse_rar_dependence() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @can_fuse_different_memrefs() {
 func @can_fuse_different_memrefs() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
-  %d = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
+  %d = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   // Set up the following dependences:
   // Make dependence from 0 to 1 on unrelated memref '%d'.
   // 1) loop0 -> loop1 on memref '%a'
   // 2) loop0 -> loop2 on memref '%b'
   // 3) loop1 -> loop2 on memref '%c'
func @can_fuse_different_memrefs() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_intermediate_store() {
 func @should_not_fuse_across_intermediate_store() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 0}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     "op0"(%v0) : (f32) -> ()
   }
 
   // Should not fuse loop nests '%i0' and '%i1' across top-level store.
   affine.store %cf7, %0[%c0] : memref<10xf32>
 
   affine.for %i1 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 1 into loop nest 0 at depth 0}}
     %v1 = affine.load %0[%i1] : memref<10xf32>
     "op1"(%v1) : (f32) -> ()
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_intermediate_load() {
 func @should_not_fuse_across_intermediate_load() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 0}}
     affine.store %cf7, %0[%i0] : memref<10xf32>
   }
 
   // Should not fuse loop nests '%i0' and '%i1' across top-level load.
   %v0 = affine.load %0[%c0] : memref<10xf32>
   "op0"(%v0) : (f32) -> ()
 
   affine.for %i1 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 1 into loop nest 0 at depth 0}}
     affine.store %cf7, %0[%i1] : memref<10xf32>
   }
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_ssa_value_def() {
 func @should_not_fuse_across_ssa_value_def() {
-  %0 = alloc() : memref<10xf32>
-  %1 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
+  %1 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 0}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     affine.store %v0, %1[%i0] : memref<10xf32>
   }
func @should_not_fuse_across_ssa_value_def() {
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_store_before_load() {
 func @should_not_fuse_store_before_load() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 2 at depth 0}}
     affine.store %cf7, %0[%i0] : memref<10xf32>
     %v0 = affine.load %0[%i0] : memref<10xf32>
   }
func @should_not_fuse_store_before_load() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_load_at_depth1() {
 func @should_not_fuse_across_load_at_depth1() {
-  %0 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 1}}
       affine.store %cf7, %0[%i0, %i1] : memref<10x10xf32>
     }
 
     %v1 = affine.load %0[%i0, %c0] : memref<10x10xf32>
 
     affine.for %i3 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 1 into loop nest 0 at depth 1}}
       affine.store %cf7, %0[%i0, %i3] : memref<10x10xf32>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_load_in_loop_at_depth1() {
 func @should_not_fuse_across_load_in_loop_at_depth1() {
-  %0 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 2 at depth 1}}
       affine.store %cf7, %0[%i0, %i1] : memref<10x10xf32>
     }
func @should_not_fuse_across_load_in_loop_at_depth1() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_store_at_depth1() {
 func @should_not_fuse_across_store_at_depth1() {
-  %0 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 1}}
       %v0 = affine.load %0[%i0, %i1] : memref<10x10xf32>
     }
 
     affine.store %cf7, %0[%i0, %c0] : memref<10x10xf32>
 
     affine.for %i3 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 1 into loop nest 0 at depth 1}}
       %v1 = affine.load %0[%i0, %i3] : memref<10x10xf32>
     }
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_store_in_loop_at_depth1() {
 func @should_not_fuse_across_store_in_loop_at_depth1() {
-  %0 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 2 at depth 1}}
       %v0 = affine.load %0[%i0, %i1] : memref<10x10xf32>
     }
func @should_not_fuse_across_store_in_loop_at_depth1() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_across_ssa_value_def_at_depth1() {
 func @should_not_fuse_across_ssa_value_def_at_depth1() {
-  %0 = alloc() : memref<10x10xf32>
-  %1 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
+  %1 = memref.alloc() : memref<10x10xf32>
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 0 into loop nest 1 at depth 1}}
       %v0 = affine.load %0[%i0, %i1] : memref<10x10xf32>
       affine.store %v0, %1[%i0, %i1] : memref<10x10xf32>
affine.for %i0 = 0 to 10 {
 
     affine.for %i2 = 0 to 10 {
       // expected-remark@-1 {{block-level dependence preventing fusion of loop nest 1 into loop nest 0 at depth 1}}
       affine.store %cf7, %0[%i0, %c2] : memref<10x10xf32>
     }
   }
   return
 }
 No newline at end of file

mlir/test/Transforms/loop-fusion-slice-computation.mlir

 // RUN: mlir-opt %s -test-loop-fusion -test-loop-fusion-slice-computation -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: func @slice_depth1_loop_nest() {
 func @slice_depth1_loop_nest() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 1) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] )}}
     affine.store %cst, %0[%i0] : memref<100xf32>
   }
   affine.for %i1 = 0 to 5 {
     // expected-remark@-1 {{slice ( src loop: 0, dst loop: 1, depth: 1 : insert point: (1, 0) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] )}}
     %1 = affine.load %0[%i1] : memref<100xf32>
   }
   return
 }
 
 // -----
 
 // Loop %i0 writes to locations [2, 17] and loop %i0 reads from locations [3, 6]
 // Slice loop bounds should be adjusted such that the load/store are for the
 // same location.
 // CHECK-LABEL: func @slice_depth1_loop_nest_with_offsets() {
 func @slice_depth1_loop_nest_with_offsets() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 2) loop bounds: [(d0) -> (d0 + 3), (d0) -> (d0 + 4)] )}}
     %a0 = affine.apply affine_map<(d0) -> (d0 + 2)>(%i0)
     affine.store %cst, %0[%a0] : memref<100xf32>
   }
   affine.for %i1 = 4 to 8 {
     // expected-remark@-1 {{slice ( src loop: 0, dst loop: 1, depth: 1 : insert point: (1, 0) loop bounds: [(d0) -> (d0 - 3), (d0) -> (d0 - 2)] )}}
     %a1 = affine.apply affine_map<(d0) -> (d0 - 1)>(%i1)
     %1 = affine.load %0[%a1] : memref<100xf32>
   }
   return
 }
 
 // -----
 
 // Slices at loop depth 1 should only slice the loop bounds of the first scf.
 // Slices at loop depth 2 should slice loop bounds of both loops.
 // CHECK-LABEL: func @slice_depth2_loop_nest() {
 func @slice_depth2_loop_nest() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 1) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] [(d0) -> (0), (d0) -> (8)] )}}
     // expected-remark@-2 {{slice ( src loop: 1, dst loop: 0, depth: 2 : insert point: (2, 1) loop bounds: [(d0, d1) -> (d0), (d0, d1) -> (d0 + 1)] [(d0, d1) -> (d1), (d0, d1) -> (d1 + 1)] )}}
     affine.for %i1 = 0 to 16 {
       affine.store %cst, %0[%i0, %i1] : memref<100x100xf32>
     }
   }

 
 // -----
 
 // The load at depth 1 in loop nest %i2 prevents slicing loop nest %i0 at depths
 // greater than 1. However, loop nest %i2 can be sliced into loop nest %i0 at
 // depths 1 and 2 because the dependent store in loop nest %i0 is at depth 2.
 // CHECK-LABEL: func @slice_depth2_loop_nest_two_loads() {
 func @slice_depth2_loop_nest_two_loads() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %c0 = constant 0 : index
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 1) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] [(d0) -> (0), (d0) -> (8)] )}}
     // expected-remark@-2 {{slice ( src loop: 1, dst loop: 0, depth: 2 : insert point: (2, 1) loop bounds: [(d0, d1) -> (d0), (d0, d1) -> (d0 + 1)] [(d0, d1) -> (0), (d0, d1) -> (8)] )}}
     affine.for %i1 = 0 to 16 {
       affine.store %cst, %0[%i0, %i1] : memref<100x100xf32>
     }

 // -----
 
 // The store at depth 1 in loop nest %i0 prevents slicing loop nest %i2 at
 // depths greater than 1 into loop nest %i0. However, loop nest %i0 can be
 // sliced into loop nest %i2 at depths 1 and 2 because the dependent load in
 // loop nest %i2 is at depth 2.
 // CHECK-LABEL: func @slice_depth2_loop_nest_two_stores() {
 func @slice_depth2_loop_nest_two_stores() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %c0 = constant 0 : index
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 2) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] [(d0) -> (0), (d0) -> (8)] )}}
     affine.for %i1 = 0 to 16 {
       affine.store %cst, %0[%i0, %i1] : memref<100x100xf32>
     }
     affine.store %cst, %0[%i0, %c0] : memref<100x100xf32>
   }
   affine.for %i2 = 0 to 10 {
     // expected-remark@-1 {{slice ( src loop: 0, dst loop: 1, depth: 1 : insert point: (1, 0) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] [(d0) -> (0), (d0) -> (16)] )}}
     // expected-remark@-2 {{slice ( src loop: 0, dst loop: 1, depth: 2 : insert point: (2, 0) loop bounds: [(d0, d1) -> (d0), (d0, d1) -> (d0 + 1)] [(d0, d1) -> (0), (d0, d1) -> (16)] )}}
     affine.for %i3 = 0 to 8 {
       %1 = affine.load %0[%i2, %i3] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
 // Test loop nest which has a smaller outer trip count than its inner scf.
 // CHECK-LABEL: func @slice_loop_nest_with_smaller_outer_trip_count() {
 func @slice_loop_nest_with_smaller_outer_trip_count() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %c0 = constant 0 : index
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 1) loop bounds: [(d0) -> (d0), (d0) -> (d0 + 1)] [(d0) -> (0), (d0) -> (10)] )}}
     // expected-remark@-2 {{slice ( src loop: 1, dst loop: 0, depth: 2 : insert point: (2, 1) loop bounds: [(d0, d1) -> (d0), (d0, d1) -> (d0 + 1)] [(d0, d1) -> (d1), (d0, d1) -> (d1 + 1)] )}}
     affine.for %i1 = 0 to 16 {
       affine.store %cst, %0[%i0, %i1] : memref<100x100xf32>
     }

mlir/test/Transforms/loop-fusion-transformation.mlir

 // RUN: mlir-opt %s -allow-unregistered-dialect -test-loop-fusion -test-loop-fusion-transformation -split-input-file -canonicalize | FileCheck %s
 
 // CHECK-LABEL: func @slice_depth1_loop_nest() {
 func @slice_depth1_loop_nest() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     affine.store %cst, %0[%i0] : memref<100xf32>
   }
   affine.for %i1 = 0 to 5 {
     %1 = affine.load %0[%i1] : memref<100xf32>
     "prevent.dce"(%1) : (f32) -> ()
   }
   // CHECK:      affine.for %[[IV0:.*]] = 0 to 5 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[%[[IV0]]] : memref<100xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[%[[IV0]]] : memref<100xf32>
   // CHECK-NEXT:   "prevent.dce"(%1) : (f32) -> ()
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_reduction_to_pointwise() {
 func @should_fuse_reduction_to_pointwise() {
-  %a = alloc() : memref<10x10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10x10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %v0 = affine.load %b[%i0] : memref<10xf32>
       %v1 = affine.load %a[%i0, %i1] : memref<10x10xf32>
       %v3 = addf %v0, %v1 : f32
func @should_fuse_reduction_to_pointwise() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_avoiding_dependence_cycle() {
 func @should_fuse_avoiding_dependence_cycle() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   // Set up the following dependences:
   // 1) loop0 -> loop1 on memref '%{{.*}}'
   // 2) loop0 -> loop2 on memref '%{{.*}}'
   // 3) loop1 -> loop2 on memref '%{{.*}}'
   affine.for %i0 = 0 to 10 {

mlir/test/Transforms/loop-fusion.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -affine-loop-fusion -split-input-file | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -affine-loop-fusion="fusion-maximal" -split-input-file | FileCheck %s --check-prefix=MAXIMAL
 
 // TODO: Add more tests:
 // *) Add nested fusion test cases when non-constant loop bound support is
 //    added to iteration domain in dependence check.
 // *) Add a test w/ floordiv/ceildiv/mod when supported in dependence check.
 // *) Add tests which check fused computation slice indexing and loop bounds.
 // TODO: Test clean up: move memref allocs to func args.
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_raw_dep_for_locality() {
 func @should_fuse_raw_dep_for_locality() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_reduction_to_pointwise() {
 func @should_fuse_reduction_to_pointwise() {
-  %a = alloc() : memref<10x10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10x10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %v0 = affine.load %b[%i0] : memref<10xf32>
       %v1 = affine.load %a[%i0, %i1] : memref<10x10xf32>
       %v3 = addf %v0, %v1 : f32

 // -----
 
 // CHECK-DAG: [[$MAP_SHIFT_MINUS_ONE_R1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
 // CHECK-DAG: [[$MAP_SHIFT_D0_BY_ONE:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)>
 // CHECK-DAG: [[$MAP_SHIFT_D1_BY_ONE:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + 1)>
 
 // CHECK-LABEL: func @should_fuse_loop_nests_with_shifts() {
 func @should_fuse_loop_nests_with_shifts() {
-  %a = alloc() : memref<10x10xf32>
+  %a = memref.alloc() : memref<10x10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 9 {
     affine.for %i1 = 0 to 9 {
       affine.store %cf7, %a[%i0 + 1, %i1 + 1] : memref<10x10xf32>
     }
   }
   affine.for %i2 = 1 to 10 {
func @should_fuse_loop_nests_with_shifts() {
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_loop_nest() {
 func @should_fuse_loop_nest() {
-  %a = alloc() : memref<10x10xf32>
-  %b = alloc() : memref<10x10xf32>
+  %a = memref.alloc() : memref<10x10xf32>
+  %b = memref.alloc() : memref<10x10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.store %cf7, %a[%i0, %i1] : memref<10x10xf32>
     }
   }
   affine.for %i2 = 0 to 10 {
     affine.for %i3 = 0 to 10 {
       %v0 = affine.load %a[%i3, %i2] : memref<10x10xf32>
       affine.store %v0, %b[%i2, %i3] : memref<10x10xf32>
     }
   }
   affine.for %i4 = 0 to 10 {
     affine.for %i5 = 0 to 10 {
       %v1 = affine.load %b[%i4, %i5] : memref<10x10xf32>
     }
   }
   // Expecting private memref for '%a' first, then private memref for '%b'.
-  // CHECK-DAG:  [[NEWA:%[0-9]+]] = alloc() : memref<1x1xf32>
-  // CHECK-DAG:  [[NEWB:%[0-9]+]] = alloc() : memref<1x1xf32>
+  // CHECK-DAG:  [[NEWA:%[0-9]+]] = memref.alloc() : memref<1x1xf32>
+  // CHECK-DAG:  [[NEWB:%[0-9]+]] = memref.alloc() : memref<1x1xf32>
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:     affine.store %{{.*}}, [[NEWA]][0, 0] : memref<1x1xf32>
   // CHECK-NEXT:     affine.load [[NEWA]][0, 0] : memref<1x1xf32>
   // CHECK-NEXT:     affine.store %{{.*}}, [[NEWB]][0, 0] : memref<1x1xf32>
   // CHECK-NEXT:     affine.load [[NEWB]][0, 0] : memref<1x1xf32>
   // CHECK-NEXT:   }
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_across_intermediate_loop_with_no_deps() {
 func @should_fuse_across_intermediate_loop_with_no_deps() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %a[%i0] : memref<10xf32>
     affine.store %v0, %b[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
func @should_fuse_across_intermediate_loop_with_no_deps() {
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_all_loops() {
 func @should_fuse_all_loops() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   // Set up flow dependences from first and second loops to third.
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     affine.store %cf7, %b[%i1] : memref<10xf32>
   }
   affine.for %i2 = 0 to 10 {
     %v0 = affine.load %a[%i2] : memref<10xf32>
     %v1 = affine.load %b[%i2] : memref<10xf32>
   }
 
   // Should fuse first and second loops into third.
   // Expecting private memref for '%a' first, then private memref for '%b'.
-  // CHECK-DAG: [[NEWA:%[0-9]+]] = alloc() : memref<1xf32>
-  // CHECK-DAG: [[NEWB:%[0-9]+]] = alloc() : memref<1xf32>
+  // CHECK-DAG: [[NEWA:%[0-9]+]] = memref.alloc() : memref<1xf32>
+  // CHECK-DAG: [[NEWB:%[0-9]+]] = memref.alloc() : memref<1xf32>
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, [[NEWA]][0] : memref<1xf32>
   // CHECK-NEXT:   affine.store %{{.*}}, [[NEWB]][0] : memref<1xf32>
   // CHECK-NEXT:   affine.load [[NEWA]][0] : memref<1xf32>
   // CHECK-NEXT:   affine.load [[NEWB]][0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_first_and_second_loops() {
 func @should_fuse_first_and_second_loops() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %a[%i1] : memref<10xf32>
func @should_fuse_first_and_second_loops() {
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_would_create_cycle() {
 func @should_not_fuse_would_create_cycle() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   // Set up the following dependences:
   // 1) loop0 -> loop1 on memref '%{{.*}}'
   // 2) loop0 -> loop2 on memref '%{{.*}}'
   // 3) loop1 -> loop2 on memref '%{{.*}}'
   affine.for %i0 = 0 to 10 {
func @should_not_fuse_would_create_cycle() {
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_producer_consumer() {
 func @should_fuse_producer_consumer() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     affine.store %cf7, %m[%i1] : memref<10xf32>
   }
   affine.for %i2 = 0 to 10 {
     %v1 = affine.load %m[%i2] : memref<10xf32>
   }
   // Fusing loop %i0 to %i2 would violate the WAW dependence between %i0 and
   // %i1, but OK to fuse %i1 into %i2.
   // TODO: When the fusion pass is run to a fixed-point, it should
   // fuse all three of these loop nests.
-  // CHECK:      alloc() : memref<1xf32>
+  // CHECK:      memref.alloc() : memref<1xf32>
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() {
 func @should_fuse_and_move_to_preserve_war_dep() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %a[%i0] : memref<10xf32>
     affine.store %v0, %b[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     affine.store %cf7, %a[%i1] : memref<10xf32>
func @should_fuse_and_move_to_preserve_war_dep() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_if_top_level_access() {
 func @should_fuse_if_top_level_access() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
 
   %c0 = constant 4 : index
   %v1 = affine.load %m[%c0] : memref<10xf32>
   // Top-level load to '%m' should prevent creating a private memref but
   // loop nests should be fused and '%i0' should be removed.
-  // CHECK:      %[[m:.*]] = alloc() : memref<10xf32>
+  // CHECK:      %[[m:.*]] = memref.alloc() : memref<10xf32>
   // CHECK-NOT:  alloc
 
   // CHECK:      affine.for %[[i1:.*]] = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %[[m]][%[[i1]]] : memref<10xf32>
   // CHECK-NEXT:   affine.load %[[m]][%[[i1]]] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK:      affine.load %[[m]][%{{.*}}] : memref<10xf32>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_but_not_remove_src() {
 func @should_fuse_but_not_remove_src() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %cf7, %m[%i0] : memref<100xf32>
   }
   affine.for %i1 = 0 to 17 {
     %v0 = affine.load %m[%i1] : memref<100xf32>
   }
func @should_fuse_but_not_remove_src() {
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_no_top_level_access() {
 func @should_fuse_no_top_level_access() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 #set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @should_not_fuse_if_inst_at_top_level() {
 func @should_not_fuse_if_inst_at_top_level() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }

 }
 
 // -----
 
 #set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @should_not_fuse_if_inst_in_loop_nest() {
 func @should_not_fuse_if_inst_in_loop_nest() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c4 = constant 4 : index
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     affine.if #set0(%c4) {
func @should_not_fuse_if_inst_in_loop_nest() {
   // CHECK-NEXT: }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @permute_and_fuse() {
 func @permute_and_fuse() {
-  %m = alloc() : memref<10x20x30xf32>
+  %m = memref.alloc() : memref<10x20x30xf32>
 
   %cf7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 20 {
       affine.for %i2 = 0 to 30 {
         affine.store %cf7, %m[%i0, %i1, %i2] : memref<10x20x30xf32>
       }
     }

 
 // CHECK-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
 // CHECK-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)>
 // CHECK-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)>
 
 // Reshape from a 64 x f32 to 16 x 4 x f32.
 // CHECK-LABEL: func @fuse_reshape_64_16_4
 func @fuse_reshape_64_16_4(%in : memref<64xf32>) {
-  %out = alloc() : memref<16x4xf32>
+  %out = memref.alloc() : memref<16x4xf32>
 
   affine.for %i0 = 0 to 64 {
     %v = affine.load %in[%i0] : memref<64xf32>
     affine.store %v, %out[%i0 floordiv 4, %i0 mod 4] : memref<16x4xf32>
   }
 
   affine.for %i1 = 0 to 16 {
     affine.for %i2 = 0 to 4 {

 // -----
 // CHECK-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)>
 // CHECK-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)>
 // CHECK-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
 
 // Reshape a 16x4xf32 to 64xf32.
 // CHECK-LABEL: func @fuse_reshape_16_4_64
 func @fuse_reshape_16_4_64() {
-  %in = alloc() : memref<16x4xf32>
-  %out = alloc() : memref<64xf32>
+  %in = memref.alloc() : memref<16x4xf32>
+  %out = memref.alloc() : memref<64xf32>
 
   affine.for %i0 = 0 to 16 {
     affine.for %i1 = 0 to 4 {
       %v = affine.load %in[%i0, %i1] : memref<16x4xf32>
       affine.store %v, %out[4*%i0 + %i1] : memref<64xf32>
     }
   }
 

 }
 
 
 // -----
 
 // All three loop nests below (6-d one, 2-d one, 2-d one is fused into a single
 // 2-d loop nest).
 func @R6_to_R2_reshape_square() -> memref<64x9xi32> {
-  %in = alloc() : memref<2x2x3x3x16x1xi32>
-  %out = alloc() : memref<64x9xi32>
-  %live_out = alloc() : memref<64x9xi32>
+  %in = memref.alloc() : memref<2x2x3x3x16x1xi32>
+  %out = memref.alloc() : memref<64x9xi32>
+  %live_out = memref.alloc() : memref<64x9xi32>
 
   // Initialize input.
   affine.for %i0 = 0 to 2 {
     affine.for %i1 = 0 to 2 {
       affine.for %i2 = 0 to 3 {
         affine.for %i3 = 0 to 3 {
           affine.for %i4 = 0 to 16 {
             affine.for %i5 = 0 to 1 {

 // CHECK-DAG: [[$MAP13:#map[0-9]+]] = affine_map<(d0) -> ((d0 mod 288) floordiv 144)>
 // CHECK-DAG: [[$MAP14:#map[0-9]+]] = affine_map<(d0) -> (((d0 mod 288) mod 144) floordiv 48)>
 // CHECK-DAG: [[$MAP15:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)>
 // CHECK-DAG: [[$MAP16:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)>
 // CHECK-DAG: [[$MAP17:#map[0-9]+]] = affine_map<(d0) -> (0)>
 
 //
 // CHECK-LABEL: func @R6_to_R2_reshape
-// CHECK:       alloc() : memref<1x2x3x3x16x1xi32>
-// CHECK:       alloc() : memref<1x1xi32>
-// CHECK:       alloc() : memref<64x9xi32>
+// CHECK:       memref.alloc() : memref<1x2x3x3x16x1xi32>
+// CHECK:       memref.alloc() : memref<1x1xi32>
+// CHECK:       memref.alloc() : memref<64x9xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 64 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // CHECK-NEXT:      affine.apply [[$MAP0]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.apply [[$MAP1]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.apply [[$MAP2]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.apply [[$MAP3]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.apply [[$MAP4]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      "foo"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index, index, index, index) -> i32

 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %{{.*}} : memref<64x9xi32>
 
 // -----
 
 // CHECK-LABEL: func @fuse_symbolic_bounds
 func @fuse_symbolic_bounds(%M : index, %N : index) {
   %N_plus_5 = affine.apply affine_map<(d0) -> (d0 + 5)>(%N)
-  %m = alloc(%M, %N_plus_5) : memref<? x ? x f32>
+  %m = memref.alloc(%M, %N_plus_5) : memref<? x ? x f32>
 
   %c0 = constant 0.0 : f32
   %s = constant 5 : index
 
   affine.for %i0 = 0 to %M {
     affine.for %i1 = 0 to affine_map<(d0) -> (d0 + 5)> (%N) {
       affine.store %c0, %m[%i0, %i1] : memref<? x ? x f32>
     }
   }
 
   affine.for %i2 = 0 to %M {
     affine.for %i3 = 0 to %N {
       %v = affine.load %m[%i2, %i3 + symbol(%s)] : memref<? x ? x f32>
     }
   }
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_reduction_at_depth_of_one
 func @should_fuse_reduction_at_depth_of_one() {
-  %a = alloc() : memref<10x100xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10x100xf32>
+  %b = memref.alloc() : memref<10xf32>
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 100 {
       %v0 = affine.load %b[%i0] : memref<10xf32>
       %v1 = affine.load %a[%i0, %i1] : memref<10x100xf32>
       %v2 = "maxf"(%v0, %v1) : (f32, f32) -> f32
       affine.store %v2, %b[%i0] : memref<10xf32>
     }
func @should_fuse_reduction_at_depth_of_one() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_at_src_depth1_and_dst_depth1
 func @should_fuse_at_src_depth1_and_dst_depth1() {
-  %a = alloc() : memref<100x16xf32>
-  %b = alloc() : memref<100x16xf32>
+  %a = memref.alloc() : memref<100x16xf32>
+  %b = memref.alloc() : memref<100x16xf32>
 
   affine.for %i0 = 0 to 100 {
     affine.for %i1 = 0 to 16 {
       %v0 = affine.load %a[%i0, %i1] : memref<100x16xf32>
       "op0"(%v0) : (f32) -> ()
     }
     affine.for %i2 = 0 to 16 {
       %v1 = "op1"() : () -> (f32)
func @should_fuse_at_src_depth1_and_dst_depth1() {
   return
 }
 
 // -----
 // CHECK: [[$MAP0:#map[0-9]*]] = affine_map<(d0, d1) -> (d0 * 10 + d1)>
 
 // CHECK-LABEL: func @should_fuse_src_depth1_at_dst_depth2
 func @should_fuse_src_depth1_at_dst_depth2() {
-  %a = alloc() : memref<100xf32>
+  %a = memref.alloc() : memref<100xf32>
   %c0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %c0, %a[%i0] : memref<100xf32>
   }
 
   affine.for %i1 = 0 to 10 {
     affine.for %i2 = 0 to 10 {
func @should_fuse_src_depth1_at_dst_depth2() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @fusion_at_depth0_not_currently_supported
 func @fusion_at_depth0_not_currently_supported() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cst = constant 0.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
     affine.store %cst, %0[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %1 = affine.load %0[%c0] : memref<10xf32>
   }
   // NOTE: Should shrink memref size to 1 element access by load in dst loop
   // nest, and make the store in the slice store to the same element.
-  // CHECK-DAG:   alloc() : memref<1xf32>
+  // CHECK-DAG:   memref.alloc() : memref<1xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:    affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_deep_loop_nests
 func @should_fuse_deep_loop_nests() {
-  %0 = alloc() : memref<2x2x3x3x16x10xf32, 2>
-  %1 = alloc() : memref<2x2x3x3x16x10xf32, 2>
-  %2 = alloc() : memref<3x3x3x3x16x10xf32, 2>
+  %0 = memref.alloc() : memref<2x2x3x3x16x10xf32, 2>
+  %1 = memref.alloc() : memref<2x2x3x3x16x10xf32, 2>
+  %2 = memref.alloc() : memref<3x3x3x3x16x10xf32, 2>
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c1_0 = constant 1 : index
   %cst = constant 0.000000e+00 : f32
   affine.for %i0 = 0 to 2 {
     affine.for %i1 = 0 to 2 {
       affine.for %i2 = 0 to 3 {
         affine.for %i3 = 0 to 3 {
affine.for %i9 = 0 to 3 {
         }
       }
     }
   }
 // The first four loops of the source loop nest can be sliced with iteration
 // bounds which are a function of the first four loops of destination loop nest,
 // where the destination loops nests have been interchanged.
 
-// CHECK-DAG:   alloc() : memref<1x1x1x1x16x10xf32, 2>
+// CHECK-DAG:   memref.alloc() : memref<1x1x1x1x16x10xf32, 2>
 // CHECK:       affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:      affine.for %{{.*}} = 0 to 2 {
 // CHECK-NEXT:        affine.for %{{.*}} = 0 to 2 {
 // CHECK-NEXT:          affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:            affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:              affine.for %{{.*}} = 0 to 16 {
 // CHECK-NEXT:                affine.for %{{.*}} = 0 to 10 {

 // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_at_depth1_and_reduce_slice_trip_count
 func @should_fuse_at_depth1_and_reduce_slice_trip_count() {
-  %a = alloc() : memref<4x256xf32>
-  %b = alloc() : memref<4x256xf32>
+  %a = memref.alloc() : memref<4x256xf32>
+  %b = memref.alloc() : memref<4x256xf32>
 
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 4 {
     affine.for %i1 = 0 to 256 {
       %v0 = affine.load %b[%i0, %i1] : memref<4x256xf32>
     }
func @should_fuse_at_depth1_and_reduce_slice_trip_count() {
   // for two reasons:
   // 1) Inserting the unsliceable src loop %i1 to a higher depth removes
   //    redundant computation and reduces costs.
   // 2) Inserting the sliceable src loop %i2 at depth 1, we can still reduce
   //    its trip count to 16 (from 256) reducing costs.
   // NOTE: the size of the private memref created for the fused loop nest
   // is reduced from the original shape from 4x256 to 4x16 because of the
   // data accessed by the load.
-  // CHECK-DAG:   alloc() : memref<1x16xf32>
+  // CHECK-DAG:   memref.alloc() : memref<1x16xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 4 {
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 256 {
   // CHECK-NEXT:      affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4x256xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 16 {
   // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 16 {
   // CHECK-NEXT:      affine.load %{{.*}}[0, %{{.*}}] : memref<1x16xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_at_depth1_with_trip_count_20
 func @should_fuse_at_depth1_with_trip_count_20() {
-  %a = alloc() : memref<100xf32>
+  %a = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %cf0, %a[%i0]: memref<100xf32>
   }
 
   affine.for %i1 = 0 to 5 {
     affine.for %i2 = 0 to 10 {
       %v0 = affine.load %a[%i2]: memref<100xf32>
     }
     affine.for %i3 = 0 to 10 {
       affine.for %i4 = 0 to 20 {
         %v1 = affine.load %a[%i4]: memref<100xf32>
       }
     }
   }
   // NOTE: The size of the private memref created for fusion is shrunk to 20xf32
-  // CHECK-DAG:   alloc() : memref<20xf32>
+  // CHECK-DAG:   memref.alloc() : memref<20xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 5 {
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 20 {
   // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<20xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:      affine.load %{{.*}}[%{{.*}}] : memref<20xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:      affine.for %{{.*}} = 0 to 20 {
   // CHECK-NEXT:        affine.load %{{.*}}[%{{.*}}] : memref<20xf32>
   // CHECK-NEXT:      }
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_at_depth1_with_trip_count_19
 func @should_fuse_at_depth1_with_trip_count_19() {
-  %a = alloc() : memref<100xf32>
+  %a = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %cf0, %a[%i0]: memref<100xf32>
   }
 
   affine.for %i1 = 0 to 5 {
     affine.for %i2 = 0 to 19 {
       %v0 = affine.load %a[%i2]: memref<100xf32>
     }
     affine.for %i3 = 0 to 10 {
       affine.for %i4 = 0 to 10 {
         %v1 = affine.load %a[%i4]: memref<100xf32>
       }
     }
   }
   // NOTE: The size of the private memref created for fusion is shrunk to 19xf32
-  // CHECK-DAG:   alloc() : memref<19xf32>
+  // CHECK-DAG:   memref.alloc() : memref<19xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 5 {
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 19 {
   // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<19xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 19 {
   // CHECK-NEXT:      affine.load %{{.*}}[%{{.*}}] : memref<19xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:        affine.load %{{.*}}[%{{.*}}] : memref<19xf32>
   // CHECK-NEXT:      }
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_with_private_memrefs_with_diff_shapes() {
 func @should_fuse_with_private_memrefs_with_diff_shapes() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %cf7, %m[%i0] : memref<100xf32>
   }
   affine.for %i1 = 0 to 17 {
     %v0 = affine.load %m[%i1] : memref<100xf32>
   }
   affine.for %i2 = 0 to 82 {
     %v1 = affine.load %m[%i2] : memref<100xf32>
   }
   // Should create two new private memrefs customized to the shapes accessed
   // by loops %{{.*}} and %{{.*}}.
-  // CHECK-DAG:  alloc() : memref<1xf32>
-  // CHECK-DAG:  alloc() : memref<1xf32>
+  // CHECK-DAG:  memref.alloc() : memref<1xf32>
+  // CHECK-DAG:  memref.alloc() : memref<1xf32>
   // CHECK:      affine.for %{{.*}} = 0 to 17 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: affine.for %{{.*}} = 0 to 82 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
func @should_fuse_live_out_arg(%arg0: memref<10xf32>) {
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_escaping_memref_but_preserve_src_loop() -> memref<10xf32>
 func @should_fuse_escaping_memref_but_preserve_src_loop() -> memref<10xf32> {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 9 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
   // This tests that the loop nest '%i0' should not be removed after fusion
   // because it writes to memref '%m', which is returned by the function, and
   // the '%i1' memory region does not cover '%i0' memory region.
 
-  // CHECK-DAG:   alloc() : memref<10xf32>
+  // CHECK-DAG:   memref.alloc() : memref<10xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  affine.for %{{.*}} = 0 to 9 {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:    affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return %{{.*}} : memref<10xf32>
   return %m : memref<10xf32>
 }
 // -----
 
 // This should fuse with the %in becoming a 1x1x1.
 func @R3_to_R2_reshape() {
-  %in = alloc() : memref<2x3x16xi32>
+  %in = memref.alloc() : memref<2x3x16xi32>
 
   %c0 = constant 0 : index
 
   affine.for %i0 = 0 to 2 {
     affine.for %i1 = 0 to 3 {
       affine.for %i2 = 0 to 16 {
         %val = "foo"(%i0, %i1, %i2) : (index, index, index) -> i32
         affine.store %val, %in[%i0, %i1, %i2] : memref<2x3x16xi32>
func @R3_to_R2_reshape() {
   }
   return
 }
 // CHECK-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 3 + d1) floordiv 48)>
 // CHECK-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 3 + d1)>
 // CHECK-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 48)>
 
 // CHECK-LABEL: func @R3_to_R2_reshape()
-// CHECK-DAG:    alloc() : memref<1x1x1xi32>
+// CHECK-DAG:    memref.alloc() : memref<1x1x1xi32>
 // CHECK:        affine.for %{{.*}} = 0 to 32 {
 // CHECK-NEXT:     affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:      affine.apply [[$MAP0]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> i32
 // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xi32>
 // CHECK-NEXT:      affine.apply [[$MAP1]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.apply [[$MAP2]](%{{.*}})
 // CHECK-NEXT:      affine.load %{{.*}}[0, 0, 0] : memref<1x1x1xi32>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 
 // -----
 
 func @should_fuse_multi_output_producer() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %a[%i0] : memref<10xf32>
     affine.store %cf7, %b[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
func @should_fuse_multi_output_producer() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @fusion_preventing_deps_on_middle_loop() {
 func @fusion_preventing_deps_on_middle_loop() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %a[%i0] : memref<10xf32>
     affine.store %v0, %b[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
func @fusion_preventing_deps_on_middle_loop() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_and_move_to_preserve_war_dep() {
 func @should_fuse_and_move_to_preserve_war_dep() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %b[%i0] : memref<10xf32>
     affine.store %v0, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 3 {
func @should_fuse_and_move_to_preserve_war_dep() {
   //     |         |     |
   //  %c |   %i2 <--     |
   //     |               |
   //     --> %i3 <--------
   //
   // It is possible to fuse loop '%i0' into '%i3' and preserve dependences
   // if the fused loop nest is inserted between loops '%i1' and '%i2'.
 
-  // CHECK-DAG:   alloc() : memref<1xf32>
+  // CHECK-DAG:   memref.alloc() : memref<1xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 3 {
   // CHECK-NEXT:    affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:    affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:    affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  affine.for %{{.*}} = 0 to 5 {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @fusion_preventing_dep_on_constant() {
 func @fusion_preventing_dep_on_constant() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %b[%i0] : memref<10xf32>
     affine.store %cf7, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
func @fusion_preventing_dep_on_constant() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_and_preserve_dep_on_constant() {
 func @should_fuse_and_preserve_dep_on_constant() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
   %cf11 = constant 11.0 : f32
   affine.for %i0 = 0 to 10 {
     %v0 = affine.load %b[%i0] : memref<10xf32>
     affine.store %cf7, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
func @should_fuse_and_preserve_dep_on_constant() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_at_depth_above_loop_carried_dependence(%{{.*}}: memref<64x4xf32>, %{{.*}}: memref<64x4xf32>) {
 func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) {
-  %out = alloc() : memref<64x4xf32>
+  %out = memref.alloc() : memref<64x4xf32>
   %0 = constant 0.0 : f32
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 4 {
       affine.store %0, %out[%i0, %i1] : memref<64x4xf32>
     }
   }
   affine.for %i2 = 0 to 4 {
     affine.for %i3 = 0 to 4 {
func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) {
   // We can fuse source loop nest '%i0' into dst loop nest '%i2', but the
   // depth at which we can insert the src loop nest slice into the dst loop
   // lest must be decreased because of a loop carried dependence on loop '%i3'.
   // As a result, the source loop nest is inserted at dst loop nest depth 1,
   // just above the loop with the carried dependence. In addition, the source
   // loop nest iteration bounds on its loop '%i1' are reduced to 1, so the
   // memref size can be reduced to 128x1xf32.
 
-  // CHECK:       alloc() : memref<64x1xf32>
+  // CHECK:       memref.alloc() : memref<64x1xf32>
   // CHECK:       affine.for %{{.*}} = 0 to 4 {
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 64 {
   // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}}, 0] : memref<64x1xf32>
   // CHECK-NEXT:    }
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 4 {
   // CHECK-NEXT:      affine.for %{{.*}} = 0 to 16 {
   // CHECK-NEXT:        affine.load %{{.*}}[%{{.*}} * 16 - %{{.*}} + 15, %{{.*}}] : memref<64x4xf32>
   // CHECK-NEXT:        "op0"(%{{.*}}) : (f32) -> ()
func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_only_two_loops_and_remove_producer() {
 func @should_fuse_only_two_loops_and_remove_producer() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
 
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %a[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %a[%i1] : memref<10xf32>
func @should_fuse_only_two_loops_and_remove_producer() {
   // CHECK-NEXT:   return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_after_one_loop_interchange() {
 func @should_fuse_after_one_loop_interchange() {
-  %a = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
 
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.store %cf0, %a[%i0] : memref<10xf32>
   }
 
   affine.for %i1 = 0 to 5 {
     affine.for %i2 = 0 to 10 {
func @should_fuse_after_one_loop_interchange() {
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_after_two_loop_interchanges() {
 func @should_fuse_after_two_loop_interchanges() {
-  %a = alloc() : memref<6x8xf32>
+  %a = memref.alloc() : memref<6x8xf32>
 
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 6 {
     affine.for %i1 = 0 to 8 {
       affine.store %cf0, %a[%i0, %i1] : memref<6x8xf32>
     }
   }
 

 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %{{.*}} : memref<32x8xf32>
 // CHECK-NEXT:}
 
 // -----
 
 // Test case which illustrates fix for b/126454413
 func @test_add_slice_bounds() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c0 = constant 0 : index
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
         %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)

 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
   return
 }
 
 // -----
 
 func @should_fuse_init_loops_siblings_then_shared_producer(%arg0: memref<10x10xf32>, %arg1: memref<10x10xf32>) {
-  %0 = alloc() : memref<10x10xf32>
+  %0 = memref.alloc() : memref<10x10xf32>
   %cst = constant 0.000000e+00 : f32
   %cst_0 = constant 1.000000e+00 : f32
   %cst_1 = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.store %cst_1, %0[%i0, %i1] : memref<10x10xf32>
     }
   }

 // CHECK-NEXT:   return
 
   return
 }
 
 // -----
 
 func @two_matrix_vector_products() {
-  %in_matrix = alloc() : memref<10x10xf32>
-  %in_vec0 = alloc() : memref<10xf32>
-  %in_vec1 = alloc() : memref<10xf32>
-  %out_vec0 = alloc() : memref<10xf32>
-  %out_vec1 = alloc() : memref<10xf32>
+  %in_matrix = memref.alloc() : memref<10x10xf32>
+  %in_vec0 = memref.alloc() : memref<10xf32>
+  %in_vec1 = memref.alloc() : memref<10xf32>
+  %out_vec0 = memref.alloc() : memref<10xf32>
+  %out_vec1 = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   // Populate input matrix.
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.store %cf7, %in_matrix[%i0, %i1] : memref<10x10xf32>
     }
   }

 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
   return
 }
 
 // -----
 
 func @should_not_slice_past_slice_barrier() {
-  %0 = alloc() : memref<100x16xf32>
+  %0 = memref.alloc() : memref<100x16xf32>
   affine.for %i0 = 0 to 100 {
     affine.for %i1 = 0 to 16 {
       %1 = "op1"() : () -> f32
       affine.store %1, %0[%i0, %i1] : memref<100x16xf32>
     } {slice_fusion_barrier = true}
   }
   affine.for %i2 = 0 to 100 {
     affine.for %i3 = 0 to 16 {

 // CHECK-NEXT:   }
   return
 }
 
 // -----
 
 #map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 func @fuse_across_dim_mismatch(%arg0: memref<4x4x16x1xf32>, %arg1: memref<144x9xf32>, %arg2: memref<9xf32>) {
-  %1 = alloc() : memref<144x4xf32>
+  %1 = memref.alloc() : memref<144x4xf32>
   %2 = constant 0.0 : f32
   affine.for %i2 = 0 to 9 {
     affine.for %i3 = 0 to 4 {
       affine.for %i5 = 0 to 16 {
         %7 = affine.apply #map0(%i2, %i5)
         affine.store %2, %1[%7, %i3] : memref<144x4xf32>
       }
     }
   }
   affine.for %i6 = 0 to 9 {
     affine.for %i7 = 0 to 9 {
       affine.for %i8 = 0 to 4 {
         affine.for %i10 = 0 to 16 {
           %10 = affine.apply #map0(%i6, %i10)
           %11 = affine.load %1[%10, %i8] : memref<144x4xf32>
         }
       }
     }
   }
   return
 }
 // MAXIMAL:      #map = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 // MAXIMAL-LABEL: func @fuse_across_dim_mismatch
-// MAXIMAL:        alloc() : memref<1x1xf32>
+// MAXIMAL:        memref.alloc() : memref<1x1xf32>
 // MAXIMAL:        affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:      affine.for %{{.*}} = 0 to 4 {
 // MAXIMAL-NEXT:        affine.for %{{.*}} = 0 to 16 {
 // MAXIMAL-NEXT:          affine.apply #map(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
 // MAXIMAL-NEXT:          affine.apply #map(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          affine.load %{{.*}}[0, 0] : memref<1x1xf32>

 #map5 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
 #map6 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
 #map7 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)>
 #map10 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 #map11 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 #map12 = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
 func @fuse_across_varying_dims_complex(%arg0: f32) {
   %c0 = constant 0 : index
-  %0 = alloc() : memref<2x2x3x3x16x1xf32>
-  %1 = alloc() : memref<64x9xf32>
-  %2 = alloc() : memref<144x4xf32>
+  %0 = memref.alloc() : memref<2x2x3x3x16x1xf32>
+  %1 = memref.alloc() : memref<64x9xf32>
+  %2 = memref.alloc() : memref<144x4xf32>
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 9 {
       %4 = affine.apply #map3(%i0, %i1)
       %5 = affine.apply #map4(%i0, %i1)
       %6 = affine.apply #map5(%i0, %i1)
       %7 = affine.apply #map6(%i0, %i1)
       %8 = affine.apply #map7(%i0, %i1)
       %9 = affine.load %0[%4, %5, %7, %8, %6, %c0] : memref<2x2x3x3x16x1xf32>

 // MAXIMAL-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)>
 // MAXIMAL-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)>
 // MAXIMAL-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
 // MAXIMAL-DAG: [[$MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
 // MAXIMAL-DAG: [[$MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)>
 // MAXIMAL-DAG: [[$MAP7:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 // MAXIMAL-DAG: [[$MAP8:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
 // MAXIMAL-LABEL: func @fuse_across_varying_dims_complex
-// MAXIMAL-NEXT:  alloc() : memref<64x1xf32>
+// MAXIMAL-NEXT:  memref.alloc() : memref<64x1xf32>
 // MAXIMAL-NEXT:  constant 0 : index
-// MAXIMAL-NEXT:  alloc() : memref<2x2x3x3x16x1xf32>
-// MAXIMAL-NEXT:  alloc() : memref<144x4xf32>
+// MAXIMAL-NEXT:  memref.alloc() : memref<2x2x3x3x16x1xf32>
+// MAXIMAL-NEXT:  memref.alloc() : memref<144x4xf32>
 // MAXIMAL-NEXT:  affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:      affine.for %{{.*}} = 0 to 4 {
 // MAXIMAL-NEXT:        affine.for %{{.*}} = 0 to 16 {
 // MAXIMAL-NEXT:          affine.for %{{.*}} = 0 to 64 {
 // MAXIMAL-NEXT:            affine.apply [[$MAP0]](%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:            affine.apply [[$MAP1]](%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:            affine.apply [[$MAP2]](%{{.*}}, %{{.*}})

 // MAXIMAL-NEXT:        }
 // MAXIMAL-NEXT:      }
 // MAXIMAL-NEXT:    }
 // MAXIMAL-NEXT:  }
 
 // -----
 
 func @should_fuse_with_slice_union() {
-  %a = alloc() : memref<100xf32>
+  %a = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %cf0, %a[%i0]: memref<100xf32>
   }
 
   affine.for %i1 = 10 to 20 {
func @affine_2_dependent_mm_fused(%arg0: memref<1024x1024xf32>, %arg1: memref<1024x1024xf32>, %arg2: memref<1024x1024xf32>, %arg3: memref<1024x1024xf32>, %arg4: memref<1024x1024xf32>) {
   // CHECK-NEXT:   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_self_dependence_multi_store_producer() {
 func @should_fuse_self_dependence_multi_store_producer() {
-  %m = alloc() : memref<10xf32>
-  %local_m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
+  %local_m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %local_m[%i0] : memref<10xf32>
     %v0 = affine.load %local_m[%i0] : memref<10xf32>
     affine.store %v0, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v1 = affine.load %m[%i1] : memref<10xf32>
   }
   // CHECK:      affine.for %[[i0:.*]] = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, [[LOCAL_M:%.*]][%[[i0]]] : memref<10xf32>
   // CHECK-NEXT:   [[v0:%.*]] = affine.load [[LOCAL_M]][%[[i0]]] : memref<10xf32>
   // CHECK-NEXT:   affine.store [[v0]], %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_dead_multi_store_producer() {
 func @should_fuse_dead_multi_store_producer() {
-  %m = alloc() : memref<10xf32>
-  %dead_m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
+  %dead_m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %dead_m[%i0] : memref<10xf32>
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
   // CHECK:      affine.for %[[i0:.*]] = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[%[[i0]]] : memref<10xf32>
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_function_live_out_multi_store_producer
 func @should_fuse_function_live_out_multi_store_producer(%live_in_out_m : memref<10xf32>) {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %live_in_out_m[%i0] : memref<10xf32>
     affine.store %cf7, %m[%i0] : memref<10xf32>
   }
   affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
   // CHECK:      affine.for %[[i0:.*]] = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[%[[i0]]] : memref<10xf32>
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT:   affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
 // Test case from github bug 777.
 // CHECK-LABEL: func @mul_add_0
 func @mul_add_0(%arg0: memref<3x4xf32>, %arg1: memref<4x3xf32>, %arg2: memref<3x3xf32>, %arg3: memref<3x3xf32>) {
   %cst = constant 0.000000e+00 : f32
-  %0 = alloc() : memref<3x3xf32>
+  %0 = memref.alloc() : memref<3x3xf32>
   affine.for %arg4 = 0 to 3 {
     affine.for %arg5 = 0 to 3 {
       affine.store %cst, %0[%arg4, %arg5] : memref<3x3xf32>
     }
   }
   affine.for %arg4 = 0 to 3 {
     affine.for %arg5 = 0 to 3 {
       affine.for %arg6 = 0 to 4 {
func @should_fuse_producer_with_multi_outgoing_edges(%a : memref<1xf32>, %b : memref<1xf32>) {
   return
 }
 
 // -----
 
 // MAXIMAL-LABEL: func @reshape_into_matmul
 func @reshape_into_matmul(%lhs : memref<1024x1024xf32>,
               %R: memref<16x64x1024xf32>, %out: memref<1024x1024xf32>) {
-  %rhs = alloc() :  memref<1024x1024xf32>
+  %rhs = memref.alloc() :  memref<1024x1024xf32>
 
   // Reshape from 3-d to 2-d.
   affine.for %i0 = 0 to 16 {
     affine.for %i1 = 0 to 64 {
       affine.for %k = 0 to 1024 {
         %v = affine.load %R[%i0, %i1, %k] : memref<16x64x1024xf32>
         affine.store %v, %rhs[64*%i0 + %i1, %k] : memref<1024x1024xf32>
       }
affine.for %j = 0 to 1024 {
         %3 = affine.load %out[%i, %j] : memref<1024x1024xf32>
         %4 = addf %3, %2 : f32
         affine.store %4, %out[%i, %j] : memref<1024x1024xf32>
       }
     }
   }
   return
 }
-// MAXIMAL-NEXT: alloc
+// MAXIMAL-NEXT: memref.alloc
 // MAXIMAL-NEXT: affine.for
 // MAXIMAL-NEXT:   affine.for
 // MAXIMAL-NEXT:     affine.for
 // MAXIMAL-NOT:      affine.for
 // MAXIMAL:      return
 
 // -----
 

 
 // -----
 
 // Test fusion when dynamically shaped memrefs are used with constant trip count loops.
 
 // CHECK-LABEL: func @calc
 func @calc(%arg0: memref<?xf32>, %arg1: memref<?xf32>, %arg2: memref<?xf32>, %len: index) {
   %c1 = constant 1 : index
-  %1 = alloc(%len) : memref<?xf32>
+  %1 = memref.alloc(%len) : memref<?xf32>
   affine.for %arg4 = 1 to 10 {
     %7 = affine.load %arg0[%arg4] : memref<?xf32>
     %8 = affine.load %arg1[%arg4] : memref<?xf32>
     %9 = addf %7, %8 : f32
     affine.store %9, %1[%arg4] : memref<?xf32>
   }
   affine.for %arg4 = 1 to 10 {
     %7 = affine.load %1[%arg4] : memref<?xf32>
     %8 = affine.load %arg1[%arg4] : memref<?xf32>
     %9 = mulf %7, %8 : f32
     affine.store %9, %arg2[%arg4] : memref<?xf32>
   }
   return
 }
-// CHECK:       alloc() : memref<1xf32>
+// CHECK:       memref.alloc() : memref<1xf32>
 // CHECK:       affine.for %arg{{.*}} = 1 to 10 {
 // CHECK-NEXT:    affine.load %arg{{.*}}
 // CHECK-NEXT:    affine.load %arg{{.*}}
 // CHECK-NEXT:    addf
 // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[0] : memref<1xf32>
 // CHECK-NEXT:    affine.load %{{.*}}[0] : memref<1xf32>
 // CHECK-NEXT:    affine.load %arg{{.*}}[%arg{{.*}}] : memref<?xf32>
 // CHECK-NEXT:    mulf
affine.for %d = 0 to 32 {
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = addf %lhs, %rhs : f32
     affine.store %add, %in0[%d] : memref<32xf32>
   }
   affine.for %d = 0 to 32 {
     %lhs = load %in0[%d] : memref<32xf32>
     %rhs = load %in1[%d] : memref<32xf32>
     %add = subf %lhs, %rhs : f32
-    store %add, %in0[%d] : memref<32xf32>
+    memref.store %add, %in0[%d] : memref<32xf32>
   }
   affine.for %d = 0 to 32 {
     %lhs = affine.load %in0[%d] : memref<32xf32>
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = mulf %lhs, %rhs : f32
     affine.store %add, %in0[%d] : memref<32xf32>
   }
   return
 }
 
 // CHECK:  affine.for
 // CHECK:    addf
 // CHECK:  affine.for
 // CHECK:    subf
 // CHECK:  affine.for
 // CHECK:    mulf
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_since_top_level_non_affine_users
 func @should_not_fuse_since_top_level_non_affine_users(%in0 : memref<32xf32>,
                       %in1 : memref<32xf32>) {
-  %sum = alloc() : memref<f32>
+  %sum = memref.alloc() : memref<f32>
   affine.for %d = 0 to 32 {
     %lhs = affine.load %in0[%d] : memref<32xf32>
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = addf %lhs, %rhs : f32
-    store %add, %sum[] : memref<f32>
+    memref.store %add, %sum[] : memref<f32>
     affine.store %add, %in0[%d] : memref<32xf32>
   }
   %load_sum = load %sum[] : memref<f32>
   affine.for %d = 0 to 32 {
     %lhs = affine.load %in0[%d] : memref<32xf32>
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = mulf %lhs, %rhs : f32
     %sub = subf %add, %load_sum: f32
     affine.store %sub, %in0[%d] : memref<32xf32>
   }
-  dealloc %sum : memref<f32>
+  memref.dealloc %sum : memref<f32>
   return
 }
 
 // CHECK:  affine.for
 // CHECK:    addf
 // CHECK:  affine.for
 // CHECK:    mulf
 // CHECK:    subf
 
 // -----
 
 // CHECK-LABEL: func @should_not_fuse_since_top_level_non_affine_mem_write_users
 func @should_not_fuse_since_top_level_non_affine_mem_write_users(
     %in0 : memref<32xf32>, %in1 : memref<32xf32>) {
   %c0 = constant 0 : index
   %cst_0 = constant 0.000000e+00 : f32
 
   affine.for %d = 0 to 32 {
     %lhs = affine.load %in0[%d] : memref<32xf32>
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = addf %lhs, %rhs : f32
     affine.store %add, %in0[%d] : memref<32xf32>
   }
-  store %cst_0, %in0[%c0] : memref<32xf32>
+  memref.store %cst_0, %in0[%c0] : memref<32xf32>
   affine.for %d = 0 to 32 {
     %lhs = affine.load %in0[%d] : memref<32xf32>
     %rhs = affine.load %in1[%d] : memref<32xf32>
     %add = addf %lhs, %rhs: f32
     affine.store %add, %in0[%d] : memref<32xf32>
   }
   return
 }
 
 // CHECK:  affine.for
 // CHECK:    addf
 // CHECK:  affine.for
 // CHECK:    addf
 
 // -----
 
 // MAXIMAL-LABEL: func @fuse_minor_affine_map
 func @fuse_minor_affine_map(%in: memref<128xf32>, %out: memref<20x512xf32>) {
-  %tmp = alloc() : memref<128xf32>
+  %tmp = memref.alloc() : memref<128xf32>
 
   affine.for %arg4 = 0 to 128 {
     %ld = affine.load %in[%arg4] : memref<128xf32>
     affine.store %ld, %tmp[%arg4] : memref<128xf32>
   }
 
   affine.for %arg3 = 0 to 20 {
     affine.for %arg4 = 0 to 512 {
       %ld = affine.load %tmp[%arg4 mod 128] : memref<128xf32>
       affine.store %ld, %out[%arg3, %arg4] : memref<20x512xf32>
     }
   }
 
   return
 }
 
 // TODO: The size of the private memref is not properly computed in the presence
 // of the 'mod' operation. It should be memref<1xf32> instead of
 // memref<128xf32>: https://bugs.llvm.org/show_bug.cgi?id=46973
-// MAXIMAL:       alloc() : memref<128xf32>
+// MAXIMAL:       memref.alloc() : memref<128xf32>
 // MAXIMAL:       affine.for
 // MAXIMAL-NEXT:    affine.for
 // MAXIMAL-NOT:   affine.for
 // MAXIMAL:       return
 
 // -----
 
 // CHECK-LABEL: func @should_fuse_multi_store_producer_and_privatize_memfefs
 func @should_fuse_multi_store_producer_and_privatize_memfefs() {
-  %a = alloc() : memref<10xf32>
-  %b = alloc() : memref<10xf32>
-  %c = alloc() : memref<10xf32>
+  %a = memref.alloc() : memref<10xf32>
+  %b = memref.alloc() : memref<10xf32>
+  %c = memref.alloc() : memref<10xf32>
   %cst = constant 0.000000e+00 : f32
   affine.for %arg0 = 0 to 10 {
     affine.store %cst, %a[%arg0] : memref<10xf32>
     affine.store %cst, %b[%arg0] : memref<10xf32>
     affine.store %cst, %c[%arg0] : memref<10xf32>
     %0 = affine.load %c[%arg0] : memref<10xf32>
   }
 

mlir/test/Transforms/loop-invariant-code-motion.mlir

 // RUN: mlir-opt %s  -split-input-file -loop-invariant-code-motion | FileCheck %s
 
 func @nested_loops_both_having_invariant_code() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %v0 = addf %cf7, %cf8 : f32
     affine.for %arg1 = 0 to 10 {
       %v1 = addf %v0, %cf8 : f32
       affine.store %v0, %m[%arg0] : memref<10xf32>
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %[[CST0:.*]] = constant 7.000000e+00 : f32
   // CHECK-NEXT: %[[CST1:.*]] = constant 8.000000e+00 : f32
   // CHECK-NEXT: %[[ADD0:.*]] = addf %[[CST0]], %[[CST1]] : f32
   // CHECK-NEXT: addf %[[ADD0]], %[[CST1]] : f32
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.store
 
   return
 }
 
 // -----
 
 func @nested_loops_code_invariant_to_both() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       %v0 = addf %cf7, %cf8 : f32
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
 
   return
 }
 
 // -----
 
 func @single_loop_nothing_invariant() {
-  %m1 = alloc() : memref<10xf32>
-  %m2 = alloc() : memref<10xf32>
+  %m1 = memref.alloc() : memref<10xf32>
+  %m2 = memref.alloc() : memref<10xf32>
   affine.for %arg0 = 0 to 10 {
     %v0 = affine.load %m1[%arg0] : memref<10xf32>
     %v1 = affine.load %m2[%arg0] : memref<10xf32>
     %v2 = addf %v0, %v1 : f32
     affine.store %v2, %m1[%arg0] : memref<10xf32>
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
-  // CHECK-NEXT: %1 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
+  // CHECK-NEXT: %1 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: %3 = affine.load %1[%arg0] : memref<10xf32>
   // CHECK-NEXT: %4 = addf %2, %3 : f32
   // CHECK-NEXT: affine.store %4, %0[%arg0] : memref<10xf32>
 
   return
 }
 
 // -----
 
 func @invariant_code_inside_affine_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
     %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
     affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         %cf9 = addf %cf8, %cf8 : f32
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %1 = affine.apply #map(%arg0)
   // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
       }
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %[[CST:.*]] = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %[[ARG:.*]] = 0 to 10 {
   // CHECK-NEXT: }
   // CHECK-NEXT: affine.for %[[ARG:.*]] = 0 to 10 {
   // CHECK-NEXT: affine.if #set(%[[ARG]], %[[ARG]]) {
   // CHECK-NEXT: addf %[[CST]], %[[CST]] : f32
   // CHECK-NEXT: }
 
   return
 }
 
 // -----
 
 func @invariant_affine_if2() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg1] : memref<10xf32>
       }
     }
   }
 
-  // CHECK: alloc
+  // CHECK: memref.alloc
   // CHECK-NEXT: constant
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: affine.store
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %cf10 = addf %cf9, %cf9 : f32
           }
       }
     }
   }
 
-  // CHECK: alloc
+  // CHECK: memref.alloc
   // CHECK-NEXT: constant
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_affine_nested_if_else() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
       affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
           affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %cf10 = addf %cf9, %cf9 : f32
           } else {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 
-  // CHECK: alloc
+  // CHECK: memref.alloc
   // CHECK-NEXT: constant
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: affine.store
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: } else {
   // CHECK-NEXT: affine.store
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
 // -----
 
 func @invariant_loop_dialect() {
   %ci0 = constant 0 : index
   %ci10 = constant 10 : index
   %ci1 = constant 1 : index
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
   scf.for %arg0 = %ci0 to %ci10 step %ci1 {
     scf.for %arg1 = %ci0 to %ci10 step %ci1 {
       %v0 = addf %cf7, %cf8 : f32
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 7.000000e+00 : f32
   // CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
   // CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
 
   return
 }
 
 // -----
 
 func @variant_loop_dialect() {
   %ci0 = constant 0 : index
   %ci10 = constant 10 : index
   %ci1 = constant 1 : index
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   scf.for %arg0 = %ci0 to %ci10 step %ci1 {
     scf.for %arg1 = %ci0 to %ci10 step %ci1 {
       %v0 = addi %arg0, %arg1 : index
     }
   }
 
-  // CHECK: %0 = alloc() : memref<10xf32>
+  // CHECK: %0 = memref.alloc() : memref<10xf32>
   // CHECK-NEXT: scf.for
   // CHECK-NEXT: scf.for
   // CHECK-NEXT: addi
 
   return
 }
 
 // -----

mlir/test/Transforms/memref-bound-check.mlir

 // RUN: mlir-opt %s -test-memref-bound-check -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: func @test() {
 func @test() {
   %zero = constant 0 : index
   %minusone = constant -1 : index
   %sym = constant 111 : index
 
-  %A = alloc() : memref<9 x 9 x i32>
-  %B = alloc() : memref<111 x i32>
+  %A = memref.alloc() : memref<9 x 9 x i32>
+  %B = memref.alloc() : memref<111 x i32>
 
   affine.for %i = -1 to 10 {
     affine.for %j = -1 to 10 {
       %idx0 = affine.apply affine_map<(d0, d1) -> (d0)>(%i, %j)
       %idx1 = affine.apply affine_map<(d0, d1) -> (d1)>(%i, %j)
       // Out of bound access.
       %x  = affine.load %A[%idx0, %idx1] : memref<9 x 9 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
affine.for %k = 0 to 10 {
       affine.store %v, %B[%minusone] : memref<111 x i32>  // expected-error {{'affine.store' op memref out of lower bound access along dimension #1}}
   }
   return
 }
 
 // CHECK-LABEL: func @test_mod_floordiv_ceildiv
 func @test_mod_floordiv_ceildiv() {
   %zero = constant 0 : index
-  %A = alloc() : memref<128 x 64 x 64 x i32>
+  %A = memref.alloc() : memref<128 x 64 x 64 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128 + 1)>(%i, %j, %j)
       %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4 + 1)>(%i, %j, %j)
       %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4)>(%i, %j, %j)
       %x  = affine.load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
       // expected-error@-2 {{'affine.load' op memref out of upper bound access along dimension #2}}
       // expected-error@-3 {{'affine.load' op memref out of upper bound access along dimension #3}}
       %idy0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128)>(%i, %j, %j)
       %idy1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4)>(%i, %j, %j)
       %idy2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4 - 1)>(%i, %j, %j)
       affine.store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'affine.store' op memref out of lower bound access along dimension #3}}
     } // CHECK: }
   } // CHECK: }
   return
 }
 
 // CHECK-LABEL: func @test_no_out_of_bounds()
 func @test_no_out_of_bounds() {
   %zero = constant 0 : index
-  %A = alloc() : memref<257 x 256 x i32>
-  %C = alloc() : memref<257 x i32>
-  %B = alloc() : memref<1 x i32>
+  %A = memref.alloc() : memref<257 x 256 x i32>
+  %C = memref.alloc() : memref<257 x i32>
+  %B = memref.alloc() : memref<1 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       // All of these accesses are in bound; check that no errors are emitted.
       // CHECK: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
       // CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<257x256xi32>
       // CHECK-NEXT: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
       // CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<1xi32>
       %idx0 = affine.apply affine_map<(d0, d1) -> ( 64 * (d0 ceildiv 64))>(%i, %j)
       // Without GCDTightenInequalities(), the upper bound on the region
       // accessed along first memref dimension would have come out as d0 <= 318
       // (instead of d0 <= 256), and led to a false positive out of bounds.
       %x  = affine.load %A[%idx0, %zero] : memref<257 x 256 x i32>
       %idy = affine.apply affine_map<(d0, d1) -> (d0 floordiv 256)>(%i, %i)
       %y  = affine.load %B[%idy] : memref<1 x i32>
     } // CHECK-NEXT: }
   }
   return
 }
 
 // CHECK-LABEL: func @mod_div
 func @mod_div() {
   %zero = constant 0 : index
-  %A = alloc() : memref<128 x 64 x 64 x i32>
+  %A = memref.alloc() : memref<128 x 64 x 64 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128 + 1)>(%i, %j, %j)
       %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4 + 1)>(%i, %j, %j)
       %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4)>(%i, %j, %j)
       %x  = affine.load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
       // expected-error@-2 {{'affine.load' op memref out of upper bound access along dimension #2}}
       // expected-error@-3 {{'affine.load' op memref out of upper bound access along dimension #3}}
       %idy0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128)>(%i, %j, %j)
       %idy1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4)>(%i, %j, %j)
       %idy2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4 - 1)>(%i, %j, %j)
       affine.store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'affine.store' op memref out of lower bound access along dimension #3}}
     }
   }
   return
 }
 
 // Tests with nested mod's and floordiv's.
 // CHECK-LABEL: func @mod_floordiv_nested() {
 func @mod_floordiv_nested() {
-  %A = alloc() : memref<256 x 256 x i32>
+  %A = memref.alloc() : memref<256 x 256 x i32>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       %idx0 = affine.apply affine_map<(d0, d1) -> ((d0 mod 1024) floordiv 4)>(%i, %j)
       %idx1 = affine.apply affine_map<(d0, d1) -> ((((d1 mod 128) mod 32) ceildiv 4) * 32)>(%i, %j)
       affine.load %A[%idx0, %idx1] : memref<256 x 256 x i32> // expected-error {{'affine.load' op memref out of upper bound access along dimension #2}}
     }
   }
   return
 }
 
 // CHECK-LABEL: func @test_semi_affine_bailout
 func @test_semi_affine_bailout(%N : index) {
-  %B = alloc() : memref<10 x i32>
+  %B = memref.alloc() : memref<10 x i32>
   affine.for %i = 0 to 10 {
     %idx = affine.apply affine_map<(d0)[s0] -> (d0 * s0)>(%i)[%N]
     %y = affine.load %B[%idx] : memref<10 x i32>
     // expected-error@-1 {{getMemRefRegion: compose affine map failed}}
   }
   return
 }
 
 // CHECK-LABEL: func @multi_mod_floordiv
 func @multi_mod_floordiv() {
-  %A = alloc() : memref<2x2xi32>
+  %A = memref.alloc() : memref<2x2xi32>
   affine.for %ii = 0 to 64 {
       %idx0 = affine.apply affine_map<(d0) -> ((d0 mod 147456) floordiv 1152)> (%ii)
       %idx1 = affine.apply affine_map<(d0) -> (((d0 mod 147456) mod 1152) floordiv 384)> (%ii)
       %v = affine.load %A[%idx0, %idx1] : memref<2x2xi32>
   }
   return
 }
 
 // CHECK-LABEL: func @delinearize_mod_floordiv
 func @delinearize_mod_floordiv() {
   %c0 = constant 0 : index
-  %in = alloc() : memref<2x2x3x3x16x1xi32>
-  %out = alloc() : memref<64x9xi32>
+  %in = memref.alloc() : memref<2x2x3x3x16x1xi32>
+  %out = memref.alloc() : memref<64x9xi32>
 
   // Reshape '%in' into '%out'.
   affine.for %ii = 0 to 64 {
     affine.for %jj = 0 to 9 {
       %a0 = affine.apply affine_map<(d0, d1) -> (d0 * (9 * 1024) + d1 * 128)> (%ii, %jj)
       %a10 = affine.apply affine_map<(d0) ->
         (d0 floordiv (2 * 3 * 3 * 128 * 128))> (%a0)
       %a11 = affine.apply affine_map<(d0) ->
func @zero_d_memref(%arg0: memref<i32>) {
   %c0 = constant 0 : i32
   // A 0-d memref always has in-bound accesses!
   affine.store %c0, %arg0[] : memref<i32>
   return
 }
 
 // CHECK-LABEL: func @out_of_bounds
 func @out_of_bounds() {
-  %in = alloc() : memref<1xi32>
+  %in = memref.alloc() : memref<1xi32>
   %c9 = constant 9 : i32
 
   affine.for %i0 = 10 to 11 {
     %idy = affine.apply affine_map<(d0) ->  (100 * d0 floordiv 1000)> (%i0)
     affine.store %c9, %in[%idy] : memref<1xi32> // expected-error {{'affine.store' op memref out of upper bound access along dimension #1}}
   }
   return
 }
 
 // -----
 
 // This test case accesses within bounds. Without removal of a certain type of
 // trivially redundant constraints (those differing only in their constant
 // term), the number of constraints here explodes, and this would return out of
 // bounds errors conservatively due to FlatAffineConstraints::kExplosionFactor.
 #map3 = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304 + ((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
 #map4 = affine_map<(d0, d1) -> ((d0 * 72 + d1) mod 2304 - (((d0 * 72 + d1) mod 2304) floordiv 1152) * 1151 - ((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) * 9 - (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3) * 3)>
 #map5 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
 // CHECK-LABEL: func @test_complex_mod_floordiv
 func @test_complex_mod_floordiv(%arg0: memref<4x4x16x1xf32>) {
   %c0 = constant 0 : index
-  %0 = alloc() : memref<1x2x3x3x16x1xf32>
+  %0 = memref.alloc() : memref<1x2x3x3x16x1xf32>
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 9 {
       %2 = affine.apply #map3(%i0, %i1)
       %3 = affine.apply #map4(%i0, %i1)
       %4 = affine.apply #map5(%i0, %i1)
       %5 = affine.load %arg0[%2, %c0, %4, %c0] : memref<4x4x16x1xf32>
     }
   }
   return
 }
 
 // -----
 
 // The first load is within bounds, but not the second one.
 #map0 = affine_map<(d0) -> (d0 mod 4)>
 #map1 = affine_map<(d0) -> (d0 mod 4 + 4)>
 
 // CHECK-LABEL: func @test_mod_bound
 func @test_mod_bound() {
-  %0 = alloc() : memref<7 x f32>
-  %1 = alloc() : memref<6 x f32>
+  %0 = memref.alloc() : memref<7 x f32>
+  %1 = memref.alloc() : memref<6 x f32>
   affine.for %i0 = 0 to 4096 {
     affine.for %i1 = #map0(%i0) to #map1(%i0) {
       affine.load %0[%i1] : memref<7 x f32>
       affine.load %1[%i1] : memref<6 x f32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
     }
   }
   return
 }
 
 // -----
 
 #map0 = affine_map<(d0) -> (d0 floordiv 4)>
 #map1 = affine_map<(d0) -> (d0 floordiv 4 + 4)>
 #map2 = affine_map<(d0) -> (4 * (d0 floordiv 4)  + d0 mod 4)>
 
 // CHECK-LABEL: func @test_floordiv_bound
 func @test_floordiv_bound() {
-  %0 = alloc() : memref<1027 x f32>
-  %1 = alloc() : memref<1026 x f32>
-  %2 = alloc() : memref<4096 x f32>
+  %0 = memref.alloc() : memref<1027 x f32>
+  %1 = memref.alloc() : memref<1026 x f32>
+  %2 = memref.alloc() : memref<4096 x f32>
   %N = constant 2048 : index
   affine.for %i0 = 0 to 4096 {
     affine.for %i1 = #map0(%i0) to #map1(%i0) {
       affine.load %0[%i1] : memref<1027 x f32>
       affine.load %1[%i1] : memref<1026 x f32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
     }
     affine.for %i2 = 0 to #map2(%N) {
affine.for %i2 = #map_lb(%i1) to #map_ub(%i1) {
         %0 = affine.load %arg0[%i2] : memref<1024xf32>
     }
   }
   return
 }
 
 // CHECK-LABEL: func @zero_d_memref
 func @zero_d_memref() {
-  %Z = alloc() : memref<f32>
+  %Z = memref.alloc() : memref<f32>
   affine.for %i = 0 to 100 {
     affine.load %Z[] : memref<f32>
   }
   return
 }

mlir/test/Transforms/memref-dataflow-opt.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -memref-dataflow-opt | FileCheck %s
 
 // CHECK-DAG: [[$MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + 1)>
 // CHECK-DAG: [[$MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0)>
 // CHECK-DAG: [[$MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d1)>
 // CHECK-DAG: [[$MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 - 1)>
 // CHECK-DAG: [[$MAP4:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
 
 // CHECK-LABEL: func @simple_store_load() {
 func @simple_store_load() {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     %v0 = affine.load %m[%i0] : memref<10xf32>
     %v1 = addf %v0, %v0 : f32
   }
   return
 // CHECK:       %{{.*}} = constant 7.000000e+00 : f32
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
 // CHECK-NEXT:    %{{.*}} = addf %{{.*}}, %{{.*}} : f32
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 }
 
 // CHECK-LABEL: func @multi_store_load() {
 func @multi_store_load() {
   %c0 = constant 0 : index
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
   %cf9 = constant 9.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     %v0 = affine.load %m[%i0] : memref<10xf32>
     %v1 = addf %v0, %v0 : f32
     affine.store %cf8, %m[%i0] : memref<10xf32>
     affine.store %cf9, %m[%i0] : memref<10xf32>
     %v2 = affine.load %m[%i0] : memref<10xf32>
     %v3 = affine.load %m[%i0] : memref<10xf32>

 
 }
 
 // The store-load forwarding can see through affine apply's since it relies on
 // dependence information.
 // CHECK-LABEL: func @store_load_affine_apply
 func @store_load_affine_apply() -> memref<10x10xf32> {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %t0 = affine.apply affine_map<(d0, d1) -> (d1 + 1)>(%i0, %i1)
       %t1 = affine.apply affine_map<(d0, d1) -> (d0)>(%i0, %i1)
       %idx0 = affine.apply affine_map<(d0, d1) -> (d1)> (%t0, %t1)
       %idx1 = affine.apply affine_map<(d0, d1) -> (d0 - 1)> (%t0, %t1)
       affine.store %cf7, %m[%idx0, %idx1] : memref<10x10xf32>
       // CHECK-NOT: affine.load %{{[0-9]+}}
       %v0 = affine.load %m[%i0, %i1] : memref<10x10xf32>
       %v1 = addf %v0, %v0 : f32
     }
   }
   // The memref and its stores won't be erased due to this memref return.
   return %m : memref<10x10xf32>
 // CHECK:       %{{.*}} = constant 7.000000e+00 : f32
-// CHECK-NEXT:  %{{.*}} = alloc() : memref<10x10xf32>
+// CHECK-NEXT:  %{{.*}} = memref.alloc() : memref<10x10xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 10 {
 // CHECK-NEXT:      %{{.*}} = affine.apply [[$MAP0]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      %{{.*}} = affine.apply [[$MAP1]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      %{{.*}} = affine.apply [[$MAP2]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      %{{.*}} = affine.apply [[$MAP3]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
 // CHECK-NEXT:      %{{.*}} = addf %{{.*}}, %{{.*}} : f32
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %{{.*}} : memref<10x10xf32>
 }
 
 // CHECK-LABEL: func @store_load_nested
 func @store_load_nested(%N : index) {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
     }
   }
   return
 // CHECK:       %{{.*}} = constant 7.000000e+00 : f32
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to %{{.*}} {
 // CHECK-NEXT:      %{{.*}} = addf %{{.*}}, %{{.*}} : f32
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 }
 
 // No forwarding happens here since either of the two stores could be the last
 // writer; store/load forwarding will however be possible here once loop live
 // out SSA scalars are available.
 // CHECK-LABEL: func @multi_store_load_nested_no_fwd
 func @multi_store_load_nested_no_fwd(%N : index) {
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       affine.store %cf8, %m[%i1] : memref<10xf32>
     }
     affine.for %i2 = 0 to %N {
       // CHECK: %{{[0-9]+}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
     }
   }
   return
 }
 
 // No forwarding happens here since both stores have a value going into
 // the load.
 // CHECK-LABEL: func @store_load_store_nested_no_fwd
 func @store_load_store_nested_no_fwd(%N : index) {
   %cf7 = constant 7.0 : f32
   %cf9 = constant 9.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       // CHECK: %{{[0-9]+}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
       affine.store %cf9, %m[%i0] : memref<10xf32>
     }
   }
   return
 }
 
 // Forwarding happens here since the last store postdominates all other stores
 // and other forwarding criteria are satisfied.
 // CHECK-LABEL: func @multi_store_load_nested_fwd
 func @multi_store_load_nested_fwd(%N : index) {
   %cf7 = constant 7.0 : f32
   %cf8 = constant 8.0 : f32
   %cf9 = constant 9.0 : f32
   %cf10 = constant 10.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       affine.store %cf8, %m[%i1] : memref<10xf32>
     }
     affine.for %i2 = 0 to %N {
       affine.store %cf9, %m[%i2] : memref<10xf32>
     }
     affine.store %cf10, %m[%i0] : memref<10xf32>
     affine.for %i3 = 0 to %N {
       // CHECK-NOT: %{{[0-9]+}} = affine.load
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
     }
   }
   return
 }
 
 // There is no unique load location for the store to forward to.
 // CHECK-LABEL: func @store_load_no_fwd
 func @store_load_no_fwd() {
   %cf7 = constant 7.0 : f32
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         // CHECK: affine.load %{{[0-9]+}}
         %v0 = affine.load %m[%i2] : memref<10xf32>
         %v1 = addf %v0, %v0 : f32
       }
     }
   }
   return
 }
 
 // Forwarding happens here as there is a one-to-one store-load correspondence.
 // CHECK-LABEL: func @store_load_fwd
 func @store_load_fwd() {
   %cf7 = constant 7.0 : f32
   %c0 = constant 0 : index
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.store %cf7, %m[%c0] : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         // CHECK-NOT: affine.load %{{[0-9]}}+
         %v0 = affine.load %m[%c0] : memref<10xf32>
         %v1 = addf %v0, %v0 : f32
       }
     }
   }
   return
 }
 
 // Although there is a dependence from the second store to the load, it is
 // satisfied by the outer surrounding loop, and does not prevent the first
 // store to be forwarded to the load.
 func @store_load_store_nested_fwd(%N : index) -> f32 {
   %cf7 = constant 7.0 : f32
   %cf9 = constant 9.0 : f32
   %c0 = constant 0 : index
   %c1 = constant 1 : index
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
       %idx = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
       affine.store %cf9, %m[%idx] : memref<10xf32>
     }
   }
   // Due to this load, the memref isn't optimized away.
   %v3 = affine.load %m[%c1] : memref<10xf32>
   return %v3 : f32
-// CHECK:       %{{.*}} = alloc() : memref<10xf32>
+// CHECK:       %{{.*}} = memref.alloc() : memref<10xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
 // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to %{{.*}} {
 // CHECK-NEXT:      %{{.*}} = addf %{{.*}}, %{{.*}} : f32
 // CHECK-NEXT:      %{{.*}} = affine.apply [[$MAP4]](%{{.*}})
 // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
func @refs_not_known_to_be_equal(%A : memref<100 x 100 x f32>, %M : index) {
   }
   return
 }
 
 // The test checks for value forwarding from vector stores to vector loads.
 // The value loaded from %in can directly be stored to %out by eliminating
 // store and load from %tmp.
 func @vector_forwarding(%in : memref<512xf32>, %out : memref<512xf32>) {
-  %tmp = alloc() : memref<512xf32>
+  %tmp = memref.alloc() : memref<512xf32>
   affine.for %i = 0 to 16 {
     %ld0 = affine.vector_load %in[32*%i] : memref<512xf32>, vector<32xf32>
     affine.vector_store %ld0, %tmp[32*%i] : memref<512xf32>, vector<32xf32>
     %ld1 = affine.vector_load %tmp[32*%i] : memref<512xf32>, vector<32xf32>
     affine.vector_store %ld1, %out[32*%i] : memref<512xf32>, vector<32xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @vector_forwarding
 // CHECK:      affine.for %{{.*}} = 0 to 16 {
 // CHECK-NEXT:   %[[LDVAL:.*]] = affine.vector_load
 // CHECK-NEXT:   affine.vector_store %[[LDVAL]],{{.*}}
 // CHECK-NEXT: }

mlir/test/Transforms/memref-dependence-check.mlir

 // RUN: mlir-opt %s -test-memref-dependence-check  -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 #set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @store_may_execute_before_load() {
 func @store_may_execute_before_load() {
-  %m = alloc() : memref<10xf32>
+  %m = memref.alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c0 = constant 4 : index
   // There is no dependence from store 0 to load 1 at depth if we take into account
   // the constraint introduced by the following `affine.if`, which indicates that
   // the store 0 will never be executed.
   affine.if #set0(%c0) {
     affine.for %i0 = 0 to 10 {
       affine.store %cf7, %m[%i0] : memref<10xf32>
func @store_may_execute_before_load() {
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @dependent_loops() {
 func @dependent_loops() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %cst = constant 7.000000e+00 : f32
   // There is a dependence from 0 to 1 at depth 1 (common surrounding loops 0)
   // because the first loop with the store dominates the second scf.
   affine.for %i0 = 0 to 10 {
     affine.store %cst, %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   }
   affine.for %i1 = 0 to 10 {
     %1 = affine.load %0[%i1] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @different_memrefs() {
 func @different_memrefs() {
-  %m.a = alloc() : memref<100xf32>
-  %m.b = alloc() : memref<100xf32>
+  %m.a = memref.alloc() : memref<100xf32>
+  %m.b = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %c1 = constant 1.0 : f32
   affine.store %c1, %m.a[%c0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   %v0 = affine.load %m.b[%c0] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_different_elements() {
 func @store_load_different_elements() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c7 = constant 7.0 : f32
   affine.store %c7, %m[%c0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   %v0 = affine.load %m[%c1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @load_store_different_elements() {
 func @load_store_different_elements() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c7 = constant 7.0 : f32
   %v0 = affine.load %m[%c1] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   affine.store %c7, %m[%c0] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_same_element() {
 func @store_load_same_element() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c11 = constant 11 : index
   %c7 = constant 7.0 : f32
   affine.store %c7, %m[%c11] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = affine.load %m[%c11] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @load_load_same_element() {
 func @load_load_same_element() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c11 = constant 11 : index
   %c7 = constant 7.0 : f32
   %v0 = affine.load %m[%c11] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   %v1 = affine.load %m[%c11] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_same_symbol(%arg0: index) {
 func @store_load_same_symbol(%arg0: index) {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.store %c7, %m[%arg0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = affine.load %m[%arg0] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_different_symbols(%arg0: index, %arg1: index) {
 func @store_load_different_symbols(%arg0: index, %arg1: index) {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.store %c7, %m[%arg0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = affine.load %m[%arg1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_diff_element_affine_apply_const() {
 func @store_load_diff_element_affine_apply_const() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c1 = constant 1 : index
   %c8 = constant 8.0 : f32
   %a0 = affine.apply affine_map<(d0) -> (d0)> (%c1)
   affine.store %c8, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c1)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_same_element_affine_apply_const() {
 func @store_load_same_element_affine_apply_const() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c9 = constant 9 : index
   %c11 = constant 11 : index
   %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c9)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   %a1 = affine.apply affine_map<(d0) -> (d0 - 1)> (%c11)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_affine_apply_symbol(%arg0: index) {
 func @store_load_affine_apply_symbol(%arg0: index) {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
   %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_affine_apply_symbol_offset(%arg0: index) {
 func @store_load_affine_apply_symbol_offset(%arg0: index) {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
   %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%arg0)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_after_range() {
 func @store_range_load_after_range() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to 10 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply affine_map<(d0) -> (d0)> (%c10)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_func_symbol(%arg0: index, %arg1: index) {
 func @store_load_func_symbol(%arg0: index, %arg1: index) {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to %arg1 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
     %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_last_in_range() {
 func @store_range_load_last_in_range() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to 10 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     // For dependence from 0 to 1, we do not have a loop carried dependence
     // because only the final write in the loop accesses the same element as the
     // load, so this dependence appears only at depth 2 (loop independent).
     affine.store %c7, %m[%a0] : memref<100xf32>
affine.for %i0 = 0 to 10 {
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_before_range() {
 func @store_range_load_before_range() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c0 = constant 0 : index
   affine.for %i0 = 1 to 11 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply affine_map<(d0) -> (d0)> (%c0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_first_in_range() {
 func @store_range_load_first_in_range() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c0 = constant 0 : index
   affine.for %i0 = 1 to 11 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     // Dependence from 0 to 1 at depth 1 is a range because all loads at
     // constant index zero are reads after first store at index zero during
     // first iteration of the scf.
     affine.store %c7, %m[%a0] : memref<100xf32>
affine.for %i0 = 1 to 11 {
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_plus_3() {
 func @store_plus_3() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 1 to 11 {
     %a0 = affine.apply affine_map<(d0) -> (d0 + 3)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [3, 3]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @load_minus_2() {
 func @load_minus_2() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 2 to 11 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply affine_map<(d0) -> (d0 - 2)> (%i0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_independent() {
 func @perfectly_nested_loops_loop_independent() {
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 11 {
     affine.for %i1 = 0 to 11 {
       // Dependence from access 0 to 1 is loop independent at depth = 3.
       %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
       %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
affine.for %i0 = 0 to 11 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth1() {
 func @perfectly_nested_loops_loop_carried_at_depth1() {
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 9 {
     affine.for %i1 = 0 to 9 {
       // Dependence from access 0 to 1 is loop carried at depth 1.
       %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
       %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
affine.for %i0 = 0 to 9 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth2() {
 func @perfectly_nested_loops_loop_carried_at_depth2() {
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // Dependence from access 0 to 1 is loop carried at depth 2.
       %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
       %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
affine.for %i0 = 0 to 10 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @one_common_loop() {
 func @one_common_loop() {
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   // There is a loop-independent dependence from access 0 to 1 at depth 2.
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
       %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
affine.for %i0 = 0 to 10 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @dependence_cycle() {
 func @dependence_cycle() {
-  %m.a = alloc() : memref<100xf32>
-  %m.b = alloc() : memref<100xf32>
+  %m.a = memref.alloc() : memref<100xf32>
+  %m.b = memref.alloc() : memref<100xf32>
 
   // Dependences:
   // *) loop-independent dependence from access 1 to 2 at depth 2.
   // *) loop-carried dependence from access 3 to 0 at depth 1.
   affine.for %i0 = 0 to 9 {
     %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     %v0 = affine.load %m.a[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
affine.for %i0 = 0 to 9 {
     // expected-remark@above {{dependence from 3 to 3 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
 func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
-  %m = alloc() : memref<10x10xf32>
+  %m = memref.alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to %arg0 {
     affine.for %i1 = 0 to %arg1 {
       %a00 = affine.apply affine_map<(d0, d1) -> (d0 - 1)> (%i0, %i1)
       %a01 = affine.apply affine_map<(d0, d1) -> (d1 + 1)> (%i0, %i1)
       %v0 = affine.load %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
affine.for %i0 = 0 to %arg0 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @war_raw_waw_deps() {
 func @war_raw_waw_deps() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
       %v0 = affine.load %m[%a0] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
affine.for %i0 = 0 to 10 {
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @mod_deps() {
 func @mod_deps() {
-  %m = alloc() : memref<100xf32>
+  %m = memref.alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     %a0 = affine.apply affine_map<(d0) -> (d0 mod 2)> (%i0)
     // Results are conservative here since we currently don't have a way to
     // represent strided sets in FlatAffineConstraints.
     %v0 = affine.load %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply affine_map<(d0) -> ( (d0 + 1) mod 2)> (%i0)
     affine.store %c7, %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = [2, 9]}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @loop_nest_depth() {
 func @loop_nest_depth() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %c7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 128 {
     affine.for %i1 = 0 to 8 {
       affine.store %c7, %0[%i0, %i1] : memref<100x100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
func @loop_nest_depth() {
   return
 }
 
 // -----
 // Test case to exercise sanity when flattening multiple expressions involving
 // mod/div's successively.
 // CHECK-LABEL: func @mod_div_3d() {
 func @mod_div_3d() {
-  %M = alloc() : memref<2x2x2xi32>
+  %M = memref.alloc() : memref<2x2x2xi32>
   %c0 = constant 0 : i32
   affine.for %i0 = 0 to 8 {
     affine.for %i1 = 0 to 8 {
       affine.for %i2 = 0 to 8 {
         %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 floordiv 4)> (%i0, %i1, %i2)
         %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 mod 2)> (%i0, %i1, %i2)
         %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 floordiv 4)> (%i0, %i1, %i2)
         affine.store %c0, %M[%idx0, %idx1, %idx2] : memref<2 x 2 x 2 x i32>
         // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 3 = [0, 0][0, 0][1, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 4 = false}}
       }
     }
   }
   return
 }
 
 // -----
 // This test case arises in the context of a 6-d to 2-d reshape.
 // CHECK-LABEL: func @delinearize_mod_floordiv
 func @delinearize_mod_floordiv() {
   %c0 = constant 0 : index
   %val = constant 0 : i32
-  %in = alloc() : memref<2x2x3x3x16x1xi32>
-  %out = alloc() : memref<64x9xi32>
+  %in = memref.alloc() : memref<2x2x3x3x16x1xi32>
+  %out = memref.alloc() : memref<64x9xi32>
 
   affine.for %i0 = 0 to 2 {
     affine.for %i1 = 0 to 2 {
       affine.for %i2 = 0 to 3 {
         affine.for %i3 = 0 to 3 {
           affine.for %i4 = 0 to 16 {
             affine.for %i5 = 0 to 1 {
               affine.store %val, %in[%i0, %i1, %i2, %i3, %i4, %i5] : memref<2x2x3x3x16x1xi32>

 
 // TODO: add more test cases involving mod's/div's.
 
 // -----
 
 // Load and store ops access the same elements in strided scf.
 // CHECK-LABEL: func @strided_loop_with_dependence_at_depth2
 func @strided_loop_with_dependence_at_depth2() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
     affine.store %cf0, %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 // Load and store ops access alternating memref elements: no dependence.
 // CHECK-LABEL: func @strided_loop_with_no_dependence
 func @strided_loop_with_no_dependence() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
     %a0 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i0)
     affine.store %cf0, %0[%a0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 // Affine.Store op accesses memref elements at offset causing loop-carried dependence.
 // CHECK-LABEL: func @strided_loop_with_loop_carried_dependence_at_depth1
 func @strided_loop_with_loop_carried_dependence_at_depth1() {
-  %0 = alloc() : memref<10xf32>
+  %0 = memref.alloc() : memref<10xf32>
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
     %a0 = affine.apply affine_map<(d0) -> (d0 + 4)>(%i0)
     affine.store %cf0, %0[%a0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [4, 4]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 // Test that the loop carried dependence from load to store on '%i0' is
 // properly computed when the load and store are at different loop depths.
 // CHECK-LABEL: func @test_dep_store_depth1_load_depth2
 func @test_dep_store_depth1_load_depth2() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
     %a0 = affine.apply affine_map<(d0) -> (d0 - 1)>(%i0)
     affine.store %cst, %0[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}

 }
 
 // -----
 
 // Test that the loop carried dependence from store to load on '%i0' is
 // properly computed when the load and store are at different loop depths.
 // CHECK-LABEL: func @test_dep_store_depth2_load_depth1
 func @test_dep_store_depth2_load_depth1() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 1)>(%i0) {
       affine.store %cst, %0[%i1] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}

 
 // -----
 
 // Test the case that `affine.if` changes the domain for both load/store simultaneously.
 #set = affine_set<(d0): (d0 - 50 >= 0)>
 
 // CHECK-LABEL: func @test_affine_for_if_same_block() {
 func @test_affine_for_if_same_block() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.if #set(%i0) {
       %1 = affine.load %0[%i0] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}

 
 // -----
 
 // Test the case that the domain that load/store access is completedly separated by `affine.if`.
 #set = affine_set<(d0): (d0 - 50 >= 0)>
 
 // CHECK-LABEL: func @test_affine_for_if_separated() {
 func @test_affine_for_if_separated() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.if #set(%i0) {
       %1 = affine.load %0[%i0] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}

 // -----
 
 // Test the case that the domain that load/store access has non-empty union set.
 #set1 = affine_set<(d0): (  d0 - 25 >= 0)>
 #set2 = affine_set<(d0): (- d0 + 75 >= 0)>
 
 // CHECK-LABEL: func @test_affine_for_if_partially_joined() {
 func @test_affine_for_if_partially_joined() {
-  %0 = alloc() : memref<100xf32>
+  %0 = memref.alloc() : memref<100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.if #set1(%i0) {
       %1 = affine.load %0[%i0] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}

 // -----
 
 // Test whether interleaved affine.for/affine.if can be properly handled.
 #set1 = affine_set<(d0): (d0 - 50 >= 0)>
 #set2 = affine_set<(d0, d1): (d0 - 75 >= 0, d1 - 50 >= 0)>
 
 // CHECK-LABEL: func @test_interleaved_affine_for_if() {
 func @test_interleaved_affine_for_if() {
-  %0 = alloc() : memref<100x100xf32>
+  %0 = memref.alloc() : memref<100x100xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.if #set1(%i0) {
       affine.for %i1 = 0 to 100 {
         %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
         // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
         // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}

 // -----
 
 // Test whether symbols can be handled .
 #set1 = affine_set<(d0)[s0]: (  d0 - s0 floordiv 2 >= 0)>
 #set2 = affine_set<(d0):     (- d0 +            51 >= 0)>
 
 // CHECK-LABEL: func @test_interleaved_affine_for_if() {
 func @test_interleaved_affine_for_if() {
-  %0 = alloc() : memref<101xf32>
+  %0 = memref.alloc() : memref<101xf32>
   %c0 = constant 0 : index
   %N = dim %0, %c0 : memref<101xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 101 {
     affine.if #set1(%i0)[%N] {
       %1 = affine.load %0[%i0] : memref<101xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}

mlir/test/Transforms/normalize-memrefs-ops.mlir

 
 #map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2 floordiv 32, d3 floordiv 64, d2 mod 32, d3 mod 64)>
 
 // Test with op_norm and maps in arguments and in the operations in the function.
 
 // CHECK-LABEL: test_norm
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x1x1x32x64xf32>)
 func @test_norm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
-    %0 = alloc() : memref<1x16x14x14xf32, #map0>
+    %0 = memref.alloc() : memref<1x16x14x14xf32, #map0>
     "test.op_norm"(%arg0, %0) : (memref<1x16x14x14xf32, #map0>, memref<1x16x14x14xf32, #map0>) -> ()
-    dealloc %0 :  memref<1x16x14x14xf32, #map0>
+    memref.dealloc %0 :  memref<1x16x14x14xf32, #map0>
 
-    // CHECK: %[[v0:.*]] = alloc() : memref<1x16x1x1x32x64xf32>
+    // CHECK: %[[v0:.*]] = memref.alloc() : memref<1x16x1x1x32x64xf32>
     // CHECK: "test.op_norm"(%[[ARG0]], %[[v0]]) : (memref<1x16x1x1x32x64xf32>, memref<1x16x1x1x32x64xf32>) -> ()
-    // CHECK: dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
+    // CHECK: memref.dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
     return
 }
 
 // Same test with op_nonnorm, with maps in the arguments and the operations in the function.
 
 // CHECK-LABEL: test_nonnorm
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x14x14xf32, #map>)
 func @test_nonnorm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
-    %0 = alloc() : memref<1x16x14x14xf32, #map0>
+    %0 = memref.alloc() : memref<1x16x14x14xf32, #map0>
     "test.op_nonnorm"(%arg0, %0) : (memref<1x16x14x14xf32, #map0>, memref<1x16x14x14xf32, #map0>) -> ()
-    dealloc %0 :  memref<1x16x14x14xf32, #map0>
+    memref.dealloc %0 :  memref<1x16x14x14xf32, #map0>
 
-    // CHECK: %[[v0:.*]] = alloc() : memref<1x16x14x14xf32, #map>
+    // CHECK: %[[v0:.*]] = memref.alloc() : memref<1x16x14x14xf32, #map>
     // CHECK: "test.op_nonnorm"(%[[ARG0]], %[[v0]]) : (memref<1x16x14x14xf32, #map>, memref<1x16x14x14xf32, #map>) -> ()
-    // CHECK: dealloc %[[v0]] : memref<1x16x14x14xf32, #map>
+    // CHECK: memref.dealloc %[[v0]] : memref<1x16x14x14xf32, #map>
     return
 }
 
 // Test with op_norm, with maps in the operations in the function.
 
 // CHECK-LABEL: test_norm_mix
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x1x1x32x64xf32>
 func @test_norm_mix(%arg0 : memref<1x16x1x1x32x64xf32>) -> () {
-    %0 = alloc() : memref<1x16x14x14xf32, #map0>
+    %0 = memref.alloc() : memref<1x16x14x14xf32, #map0>
     "test.op_norm"(%arg0, %0) : (memref<1x16x1x1x32x64xf32>, memref<1x16x14x14xf32, #map0>) -> ()
-    dealloc %0 :  memref<1x16x14x14xf32, #map0>
+    memref.dealloc %0 :  memref<1x16x14x14xf32, #map0>
 
-    // CHECK: %[[v0:.*]] = alloc() : memref<1x16x1x1x32x64xf32>
+    // CHECK: %[[v0:.*]] = memref.alloc() : memref<1x16x1x1x32x64xf32>
     // CHECK: "test.op_norm"(%[[ARG0]], %[[v0]]) : (memref<1x16x1x1x32x64xf32>, memref<1x16x1x1x32x64xf32>) -> ()
-    // CHECK: dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
+    // CHECK: memref.dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
     return
 }
 
 // Test with maps in load and store ops.
 
 #map_tile = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2 floordiv 32, d3 floordiv 32, d2 mod 32, d3 mod 32)>
 
 // CHECK-LABEL: test_load_store
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x14x14xf32>
 func @test_load_store(%arg0 : memref<1x16x14x14xf32>) -> () {
-    %0 = alloc() : memref<1x16x14x14xf32, #map_tile>
-    // CHECK: %[[v0:.*]] = alloc() : memref<1x16x1x1x32x32xf32>
-    %1 = alloc() : memref<1x16x14x14xf32>
-    // CHECK: %[[v1:.*]] = alloc() : memref<1x16x14x14xf32>
+    %0 = memref.alloc() : memref<1x16x14x14xf32, #map_tile>
+    // CHECK: %[[v0:.*]] = memref.alloc() : memref<1x16x1x1x32x32xf32>
+    %1 = memref.alloc() : memref<1x16x14x14xf32>
+    // CHECK: %[[v1:.*]] = memref.alloc() : memref<1x16x14x14xf32>
     "test.op_norm"(%0, %1) : (memref<1x16x14x14xf32, #map_tile>, memref<1x16x14x14xf32>) -> ()
     // CHECK: "test.op_norm"(%[[v0]], %[[v1]]) : (memref<1x16x1x1x32x32xf32>, memref<1x16x14x14xf32>) -> ()
     %cst = constant 3.0 : f32
     affine.for %i = 0 to 1 {
       affine.for %j = 0 to 16 {
         affine.for %k = 0 to 14 {
           affine.for %l = 0 to 14 {
             %2 = load %1[%i, %j, %k, %l] : memref<1x16x14x14xf32>
             // CHECK: memref<1x16x14x14xf32>
             %3 = addf %2, %cst : f32
-            store %3, %arg0[%i, %j, %k, %l] : memref<1x16x14x14xf32>
+            memref.store %3, %arg0[%i, %j, %k, %l] : memref<1x16x14x14xf32>
             // CHECK: memref<1x16x14x14xf32>
           }
         }
       }
     }
-    dealloc %0 :  memref<1x16x14x14xf32, #map_tile>
-    // CHECK: dealloc %[[v0]] : memref<1x16x1x1x32x32xf32>
-    dealloc %1 :  memref<1x16x14x14xf32>
-    // CHECK: dealloc %[[v1]] : memref<1x16x14x14xf32>
+    memref.dealloc %0 :  memref<1x16x14x14xf32, #map_tile>
+    // CHECK: memref.dealloc %[[v0]] : memref<1x16x1x1x32x32xf32>
+    memref.dealloc %1 :  memref<1x16x14x14xf32>
+    // CHECK: memref.dealloc %[[v1]] : memref<1x16x14x14xf32>
     return
 }
 
 // Test with op_norm_ret, with maps in the results of normalizable operation.
 
 // CHECK-LABEL: test_norm_ret
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x1x1x32x32xf32>) -> (memref<1x16x1x1x32x32xf32>, memref<1x16x14x14xf32>) {
 func @test_norm_ret(%arg0: memref<1x16x14x14xf32, #map_tile>) -> (memref<1x16x14x14xf32, #map_tile>, memref<1x16x14x14xf32>) {
-    %0 = alloc() : memref<1x16x14x14xf32, #map_tile>
-    // CHECK-NEXT: %[[v0:.*]] = alloc() : memref<1x16x1x1x32x32xf32>
+    %0 = memref.alloc() : memref<1x16x14x14xf32, #map_tile>
+    // CHECK-NEXT: %[[v0:.*]] = memref.alloc() : memref<1x16x1x1x32x32xf32>
     %1, %2 = "test.op_norm_ret"(%arg0) : (memref<1x16x14x14xf32, #map_tile>) -> (memref<1x16x14x14xf32, #map_tile>, memref<1x16x14x14xf32>)
     // CHECK-NEXT: %[[v1:.*]], %[[v2:.*]] = "test.op_norm_ret"
     // CHECK-SAME: (memref<1x16x1x1x32x32xf32>) -> (memref<1x16x1x1x32x32xf32>, memref<1x16x14x14xf32>)
     "test.op_norm"(%1, %0) : (memref<1x16x14x14xf32, #map_tile>, memref<1x16x14x14xf32, #map_tile>) -> ()
     // CHECK-NEXT: "test.op_norm"
     // CHECK-SAME: : (memref<1x16x1x1x32x32xf32>, memref<1x16x1x1x32x32xf32>) -> ()
-    dealloc %0 : memref<1x16x14x14xf32, #map_tile>
-    // CHECK-NEXT: dealloc %[[v0]] : memref<1x16x1x1x32x32xf32>
+    memref.dealloc %0 : memref<1x16x14x14xf32, #map_tile>
+    // CHECK-NEXT: memref.dealloc %[[v0]] : memref<1x16x1x1x32x32xf32>
     return %1, %2 : memref<1x16x14x14xf32, #map_tile>, memref<1x16x14x14xf32>
     // CHECK-NEXT: return %[[v1]], %[[v2]] : memref<1x16x1x1x32x32xf32>, memref<1x16x14x14xf32>
 }
 
 // Test with an arbitrary op that references the function symbol.
 
 "test.op_funcref"() {func = @test_norm_mix} : () -> ()

mlir/test/Transforms/normalize-memrefs.mlir

 // RUN: mlir-opt -normalize-memrefs -allow-unregistered-dialect %s | FileCheck %s
 
 // This file tests whether the memref type having non-trivial map layouts
 // are normalized to trivial (identity) layouts.
 
 // CHECK-LABEL: func @permute()
 func @permute() {
-  %A = alloc() : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
+  %A = memref.alloc() : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
   affine.for %i = 0 to 64 {
     affine.for %j = 0 to 256 {
       %1 = affine.load %A[%i, %j] : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
       "prevent.dce"(%1) : (f32) -> ()
     }
   }
-  dealloc %A : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
+  memref.dealloc %A : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
   return
 }
 // The old memref alloc should disappear.
 // CHECK-NOT:  memref<64x256xf32>
-// CHECK:      [[MEM:%[0-9]+]] = alloc() : memref<256x64xf32>
+// CHECK:      [[MEM:%[0-9]+]] = memref.alloc() : memref<256x64xf32>
 // CHECK-NEXT: affine.for %[[I:arg[0-9]+]] = 0 to 64 {
 // CHECK-NEXT:   affine.for %[[J:arg[0-9]+]] = 0 to 256 {
 // CHECK-NEXT:     affine.load [[MEM]][%[[J]], %[[I]]] : memref<256x64xf32>
 // CHECK-NEXT:     "prevent.dce"
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
-// CHECK-NEXT: dealloc [[MEM]]
+// CHECK-NEXT: memref.dealloc [[MEM]]
 // CHECK-NEXT: return
 
 // CHECK-LABEL: func @shift
 func @shift(%idx : index) {
-  // CHECK-NEXT: alloc() : memref<65xf32>
-  %A = alloc() : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
+  // CHECK-NEXT: memref.alloc() : memref<65xf32>
+  %A = memref.alloc() : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
   // CHECK-NEXT: affine.load %{{.*}}[symbol(%arg0) + 1] : memref<65xf32>
   affine.load %A[%idx] : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
   affine.for %i = 0 to 64 {
     %1 = affine.load %A[%i] : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
     "prevent.dce"(%1) : (f32) -> ()
     // CHECK: %{{.*}} = affine.load %{{.*}}[%arg{{.*}} + 1] : memref<65xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @high_dim_permute()
 func @high_dim_permute() {
   // CHECK-NOT: memref<64x128x256xf32,
-  %A = alloc() : memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
+  %A = memref.alloc() : memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
   // CHECK: %[[I:arg[0-9]+]]
   affine.for %i = 0 to 64 {
     // CHECK: %[[J:arg[0-9]+]]
     affine.for %j = 0 to 128 {
       // CHECK: %[[K:arg[0-9]+]]
       affine.for %k = 0 to 256 {
         %1 = affine.load %A[%i, %j, %k] : memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
         // CHECK: %{{.*}} = affine.load %{{.*}}[%[[K]], %[[I]], %[[J]]] : memref<256x64x128xf32>
         "prevent.dce"(%1) : (f32) -> ()
       }
     }
   }
   return
 }
 
 // CHECK-LABEL: func @invalid_map
 func @invalid_map() {
-  %A = alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (d0, -d1 - 10)>>
-  // CHECK: %{{.*}} = alloc() : memref<64x128xf32,
+  %A = memref.alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (d0, -d1 - 10)>>
+  // CHECK: %{{.*}} = memref.alloc() : memref<64x128xf32,
   return
 }
 
 // A tiled layout.
 // CHECK-LABEL: func @data_tiling
 func @data_tiling(%idx : index) {
-  // CHECK: alloc() : memref<8x32x8x16xf32>
-  %A = alloc() : memref<64x512xf32, affine_map<(d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>>
+  // CHECK: memref.alloc() : memref<8x32x8x16xf32>
+  %A = memref.alloc() : memref<64x512xf32, affine_map<(d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>>
   // CHECK: affine.load %{{.*}}[symbol(%arg0) floordiv 8, symbol(%arg0) floordiv 16, symbol(%arg0) mod 8, symbol(%arg0) mod 16]
   %1 = affine.load %A[%idx, %idx] : memref<64x512xf32, affine_map<(d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>>
   "prevent.dce"(%1) : (f32) -> ()
   return
 }
 
 // Strides 2 and 4 along respective dimensions.
 // CHECK-LABEL: func @strided
 func @strided() {
-  %A = alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (2*d0, 4*d1)>>
+  %A = memref.alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (2*d0, 4*d1)>>
   // CHECK: affine.for %[[IV0:.*]] =
   affine.for %i = 0 to 64 {
     // CHECK: affine.for %[[IV1:.*]] =
     affine.for %j = 0 to 128 {
       // CHECK: affine.load %{{.*}}[%[[IV0]] * 2, %[[IV1]] * 4] : memref<127x509xf32>
       %1 = affine.load %A[%i, %j] : memref<64x128xf32, affine_map<(d0, d1) -> (2*d0, 4*d1)>>
       "prevent.dce"(%1) : (f32) -> ()
     }
   }
   return
 }
 
 // Strided, but the strides are in the linearized space.
 // CHECK-LABEL: func @strided_cumulative
 func @strided_cumulative() {
-  %A = alloc() : memref<2x5xf32, affine_map<(d0, d1) -> (3*d0 + 17*d1)>>
+  %A = memref.alloc() : memref<2x5xf32, affine_map<(d0, d1) -> (3*d0 + 17*d1)>>
   // CHECK: affine.for %[[IV0:.*]] =
   affine.for %i = 0 to 2 {
     // CHECK: affine.for %[[IV1:.*]] =
     affine.for %j = 0 to 5 {
       // CHECK: affine.load %{{.*}}[%[[IV0]] * 3 + %[[IV1]] * 17] : memref<72xf32>
       %1 = affine.load %A[%i, %j]  : memref<2x5xf32, affine_map<(d0, d1) -> (3*d0 + 17*d1)>>
       "prevent.dce"(%1) : (f32) -> ()
     }
   }
   return
 }
 
 // Symbolic operand for alloc, although unused. Tests replaceAllMemRefUsesWith
 // when the index remap has symbols.
 // CHECK-LABEL: func @symbolic_operands
 func @symbolic_operands(%s : index) {
-  // CHECK: alloc() : memref<100xf32>
-  %A = alloc()[%s] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>>
+  // CHECK: memref.alloc() : memref<100xf32>
+  %A = memref.alloc()[%s] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>>
   affine.for %i = 0 to 10 {
     affine.for %j = 0 to 10 {
       // CHECK: affine.load %{{.*}}[%{{.*}} * 10 + %{{.*}}] : memref<100xf32>
       %1 = affine.load %A[%i, %j] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>>
       "prevent.dce"(%1) : (f32) -> ()
     }
   }
   return
 }
 
 // Semi-affine maps, normalization not implemented yet.
 // CHECK-LABEL: func @semi_affine_layout_map
 func @semi_affine_layout_map(%s0: index, %s1: index) {
-  %A = alloc()[%s0, %s1] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>>
+  %A = memref.alloc()[%s0, %s1] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 1024 {
       // CHECK: memref<256x1024xf32, #map{{[0-9]+}}>
       affine.load %A[%i, %j] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>>
     }
   }
   return
 }
 
 // CHECK-LABEL: func @alignment
 func @alignment() {
-  %A = alloc() {alignment = 32 : i64}: memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
-  // CHECK-NEXT: alloc() {alignment = 32 : i64} : memref<256x64x128xf32>
+  %A = memref.alloc() {alignment = 32 : i64}: memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
+  // CHECK-NEXT: memref.alloc() {alignment = 32 : i64} : memref<256x64x128xf32>
   return
 }
 
 #tile = affine_map < (i)->(i floordiv 4, i mod 4) >
 
 // Following test cases check the inter-procedural memref normalization.
 
 // Test case 1: Check normalization for multiple memrefs in a function argument list.

 // CHECK: affine.store %[[p]], %[[A]][2, 2] : memref<4x4xf64>
 // CHECK: call @single_argument_type(%[[C]]) : (memref<2x4xf64>) -> ()
 // CHECK: return %[[B]] : f64
 
 // Test case 2: Check normalization for single memref argument in a function.
 // CHECK-LABEL: func @single_argument_type
 // CHECK-SAME: (%[[C:arg[0-9]+]]: memref<2x4xf64>)
 func @single_argument_type(%C : memref<8xf64, #tile>) {
-  %a = alloc(): memref<8xf64, #tile>
-  %b = alloc(): memref<16xf64, #tile>
+  %a = memref.alloc(): memref<8xf64, #tile>
+  %b = memref.alloc(): memref<16xf64, #tile>
   %d = constant 23.0 : f64
-  %e = alloc(): memref<24xf64>
+  %e = memref.alloc(): memref<24xf64>
   call @single_argument_type(%a): (memref<8xf64, #tile>) -> ()
   call @single_argument_type(%C): (memref<8xf64, #tile>) -> ()
   call @multiple_argument_type(%b, %d, %a, %e): (memref<16xf64, #tile>, f64, memref<8xf64, #tile>, memref<24xf64>) -> f64
   return
 }
 
-// CHECK: %[[a:[0-9]+]] = alloc() : memref<2x4xf64>
-// CHECK: %[[b:[0-9]+]] = alloc() : memref<4x4xf64>
+// CHECK: %[[a:[0-9]+]] = memref.alloc() : memref<2x4xf64>
+// CHECK: %[[b:[0-9]+]] = memref.alloc() : memref<4x4xf64>
 // CHECK: %cst = constant 2.300000e+01 : f64
-// CHECK: %[[e:[0-9]+]] = alloc() : memref<24xf64>
+// CHECK: %[[e:[0-9]+]] = memref.alloc() : memref<24xf64>
 // CHECK: call @single_argument_type(%[[a]]) : (memref<2x4xf64>) -> ()
 // CHECK: call @single_argument_type(%[[C]]) : (memref<2x4xf64>) -> ()
 // CHECK: call @multiple_argument_type(%[[b]], %cst, %[[a]], %[[e]]) : (memref<4x4xf64>, f64, memref<2x4xf64>, memref<24xf64>) -> f64
 
 // Test case 3: Check function returning any other type except memref.
 // CHECK-LABEL: func @non_memref_ret
 // CHECK-SAME: (%[[C:arg[0-9]+]]: memref<2x4xf64>) -> i1
 func @non_memref_ret(%A: memref<8xf64, #tile>) -> i1 {

 // CHECK:   %[[res:[0-9]+]]:2 = call @ret_single_argument_type(%[[C]]) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
 // CHECK:   return %[[res]]#1, %[[p]] : memref<2x4xf64>, f64
 // CHECK: ^bb2:  // pred: ^bb0
 // CHECK:   return %{{.*}}, %{{.*}} : memref<2x4xf64>, f64
 
 // CHECK-LABEL: func @ret_single_argument_type
 // CHECK-SAME: (%[[C:arg[0-9]+]]: memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
 func @ret_single_argument_type(%C: memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>){
-  %a = alloc() : memref<8xf64, #tile>
-  %b = alloc() : memref<16xf64, #tile>
+  %a = memref.alloc() : memref<8xf64, #tile>
+  %b = memref.alloc() : memref<16xf64, #tile>
   %d = constant 23.0 : f64
   call @ret_single_argument_type(%a) : (memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>)
   call @ret_single_argument_type(%C) : (memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>)
   %res1, %res2 = call @ret_multiple_argument_type(%b, %d, %a) : (memref<16xf64, #tile>, f64, memref<8xf64, #tile>) -> (memref<8xf64, #tile>, f64)
   %res3, %res4 = call @ret_single_argument_type(%res1) : (memref<8xf64, #tile>) -> (memref<16xf64, #tile>, memref<8xf64, #tile>)
   return %b, %a: memref<16xf64, #tile>, memref<8xf64, #tile>
 }
 
-// CHECK: %[[a:[0-9]+]] = alloc() : memref<2x4xf64>
-// CHECK: %[[b:[0-9]+]] = alloc() : memref<4x4xf64>
+// CHECK: %[[a:[0-9]+]] = memref.alloc() : memref<2x4xf64>
+// CHECK: %[[b:[0-9]+]] = memref.alloc() : memref<4x4xf64>
 // CHECK: %cst = constant 2.300000e+01 : f64
 // CHECK: %[[resA:[0-9]+]]:2 = call @ret_single_argument_type(%[[a]]) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
 // CHECK: %[[resB:[0-9]+]]:2 = call @ret_single_argument_type(%[[C]]) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
 // CHECK: %[[resC:[0-9]+]]:2 = call @ret_multiple_argument_type(%[[b]], %cst, %[[a]]) : (memref<4x4xf64>, f64, memref<2x4xf64>) -> (memref<2x4xf64>, f64)
 // CHECK: %[[resD:[0-9]+]]:2 = call @ret_single_argument_type(%[[resC]]#0) : (memref<2x4xf64>) -> (memref<4x4xf64>, memref<2x4xf64>)
 // CHECK: return %{{.*}}, %{{.*}} : memref<4x4xf64>, memref<2x4xf64>
 
 // Test case set #5: To check normalization in a chain of interconnected functions.

 func private @external_func_A(memref<16xf64, #tile>) -> ()
 
 // CHECK-LABEL: func private @external_func_B
 // CHECK-SAME: (memref<4x4xf64>, f64) -> memref<2x4xf64>
 func private @external_func_B(memref<16xf64, #tile>, f64) -> (memref<8xf64, #tile>)
 
 // CHECK-LABEL: func @simply_call_external()
 func @simply_call_external() {
-  %a = alloc() : memref<16xf64, #tile>
+  %a = memref.alloc() : memref<16xf64, #tile>
   call @external_func_A(%a) : (memref<16xf64, #tile>) -> ()
   return
 }
-// CHECK: %[[a:[0-9]+]] = alloc() : memref<4x4xf64>
+// CHECK: %[[a:[0-9]+]] = memref.alloc() : memref<4x4xf64>
 // CHECK: call @external_func_A(%[[a]]) : (memref<4x4xf64>) -> ()
 
 // CHECK-LABEL: func @use_value_of_external
 // CHECK-SAME: (%[[A:arg[0-9]+]]: memref<4x4xf64>, %[[B:arg[0-9]+]]: f64) -> memref<2x4xf64>
 func @use_value_of_external(%A: memref<16xf64, #tile>, %B: f64) -> (memref<8xf64, #tile>) {
   %res = call @external_func_B(%A, %B) : (memref<16xf64, #tile>, f64) -> (memref<8xf64, #tile>)
   return %res : memref<8xf64, #tile>
 }
 // CHECK: %[[res:[0-9]+]] = call @external_func_B(%[[A]], %[[B]]) : (memref<4x4xf64>, f64) -> memref<2x4xf64>
 // CHECK: return %{{.*}} : memref<2x4xf64>

mlir/test/Transforms/pipeline-data-transfer.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -affine-pipeline-data-transfer | FileCheck %s
 
 // -----
 
 // CHECK-DAG: [[$MOD_2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 2)>
 // CHECK-DAG: [[$MAP_MINUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
 
 // CHECK-LABEL: func @loop_nest_dma() {
 func @loop_nest_dma() {
 
-  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
-  %Ah = alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
+  %A = memref.alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = memref.alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
 
-  %tag = alloc() : memref<1 x f32>
+  %tag = memref.alloc() : memref<1 x f32>
 
   %zero = constant 0 : index
   %num_elts = constant 32 : index
 
   affine.for %i = 0 to 8 {
     affine.dma_start %A[%i], %Ah[%i], %tag[%zero], %num_elts : memref<256 x f32>, memref<32 x f32, 1>, memref<1 x f32>
     affine.dma_wait %tag[%zero], %num_elts : memref<1 x f32>
     %v = affine.load %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     %r = "compute"(%v) : (f32) -> (f32)
     affine.store %r, %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     affine.for %j = 0 to 32 {
       "do_more_compute"(%i, %j) : (index, index) -> ()
     }
   }
-  dealloc %tag : memref<1 x f32>
-  dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
+  memref.dealloc %tag : memref<1 x f32>
+  memref.dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
   return
 }
-// CHECK:       %{{.*}} = alloc() : memref<256xf32>
-// CHECK:       %{{.*}} = alloc() : memref<2x32xf32, 1>
-// CHECK-NEXT:  %{{.*}} = alloc() : memref<2x1xf32>
+// CHECK:       %{{.*}} = memref.alloc() : memref<256xf32>
+// CHECK:       %{{.*}} = memref.alloc() : memref<2x32xf32, 1>
+// CHECK-NEXT:  %{{.*}} = memref.alloc() : memref<2x1xf32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 1 to 8 {
 // CHECK-NEXT:    affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
 // CHECK-NEXT:    affine.apply [[$MAP_MINUS_1]](%{{.*}})
 // CHECK-NEXT:    affine.apply [[$MOD_2]](%{{.*}})
 // CHECK-NEXT:    affine.apply [[$MOD_2]](%{{.*}})
 // CHECK-NEXT:    affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xf32>
 // CHECK-NEXT:    affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
 // CHECK-NEXT:    "compute"(%{{.*}}) : (f32) -> f32
 // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 32 {
 // CHECK-NEXT:      "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> ()
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.apply [[$MAP_MINUS_1]](%{{.*}})
 // CHECK-NEXT:  affine.apply [[$MOD_2]](%{{.*}})
 // CHECK-NEXT:  affine.apply [[$MOD_2]](%{{.*}})
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xf32>
 // CHECK-NEXT:  affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
 // CHECK-NEXT:  "compute"(%{{.*}}) : (f32) -> f32
 // CHECK-NEXT:  affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 32 {
 // CHECK-NEXT:    "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> ()
 // CHECK-NEXT:  }
-// CHECK-NEXT:  dealloc %{{.*}} : memref<2x1xf32>
-// CHECK-NEXT:  dealloc %{{.*}} : memref<2x32xf32, 1>
+// CHECK-NEXT:  memref.dealloc %{{.*}} : memref<2x1xf32>
+// CHECK-NEXT:  memref.dealloc %{{.*}} : memref<2x32xf32, 1>
 // CHECK-NEXT:  return
 // CHECK-NEXT:}
 
 // -----
 
 // CHECK-DAG: [[$FLOOR_MOD_2:#map[0-9]+]] = affine_map<(d0) -> ((d0 floordiv 4) mod 2)>
 // CHECK-DAG: [[$REMAP_SHIFT_MINUS_4:#map[0-9]+]] = affine_map<(d0) -> (d0 - 4)>
 
 // CHECK-LABEL: @loop_step
 func @loop_step(%arg0: memref<512xf32>,
                   %arg1: memref<512xf32>) {
   %c0 = constant 0 : index
   %c4 = constant 4 : index
   affine.for %i0 = 0 to 512 step 4 {
-    %1 = alloc() : memref<4xf32, 1>
-    %2 = alloc() : memref<1xi32>
+    %1 = memref.alloc() : memref<4xf32, 1>
+    %2 = memref.alloc() : memref<1xi32>
     affine.dma_start %arg0[%i0], %1[%c0], %2[%c0], %c4,
               : memref<512xf32>, memref<4xf32, 1>, memref<1xi32>
     affine.dma_wait %2[%c0], %c4 : memref<1xi32>
     "compute"(%i0) : (index) -> ()
-    dealloc %2 : memref<1xi32>
-    dealloc %1 : memref<4xf32, 1>
+    memref.dealloc %2 : memref<1xi32>
+    memref.dealloc %1 : memref<4xf32, 1>
   }
   return
 }
-// CHECK:        [[BUF:%[0-9]+]] = alloc() : memref<2x4xf32, 1>
-// CHECK:        [[TAG:%[0-9]+]] = alloc() : memref<2x1xi32>
+// CHECK:        [[BUF:%[0-9]+]] = memref.alloc() : memref<2x4xf32, 1>
+// CHECK:        [[TAG:%[0-9]+]] = memref.alloc() : memref<2x1xi32>
 // CHECK-NEXT:   affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, 0], [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
 // CHECK-NEXT:   affine.for %{{.*}} = 4 to 512 step 4 {
 // CHECK-NEXT:     affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, 0], [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
 // CHECK-NEXT:     affine.apply [[$REMAP_SHIFT_MINUS_4]](%{{.*}})
 // CHECK-NEXT:     affine.apply [[$FLOOR_MOD_2]](%{{.*}})
 // CHECK:          affine.dma_wait [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<2x1xi32>
 // CHECK-NEXT:     "compute"(%{{.*}}) : (index) -> ()
 // CHECK-NEXT:   }
 // CHECK-NEXT:   [[SHIFTED:%[0-9]+]] = affine.apply [[$REMAP_SHIFT_MINUS_4]](%{{.*}})
 // CHECK-NEXT:   %{{.*}} = affine.apply [[$FLOOR_MOD_2]]([[SHIFTED]])
 // CHECK:        affine.dma_wait [[TAG]][(%{{.*}} floordiv 4) mod 2, 0], %{{.*}} : memref<2x1xi32>
 // CHECK-NEXT:   "compute"(%{{.*}}) : (index) -> ()
-// CHECK-NEXT:   dealloc [[TAG]] : memref<2x1xi32>
-// CHECK-NEXT:   dealloc [[BUF]] : memref<2x4xf32, 1>
+// CHECK-NEXT:   memref.dealloc [[TAG]] : memref<2x1xi32>
+// CHECK-NEXT:   memref.dealloc [[BUF]] : memref<2x4xf32, 1>
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 
 // -----
 
 #map1 = affine_map<(d0, d1) -> ((d0 * 2048 + d1 * 256) floordiv 32)>
 #map2 = affine_map<(d0) -> ((d0 * 2048) floordiv 32)>
 // CHECK-LABEL: func @loop_dma_nested(%{{.*}}: memref<512x32xvector<8xf32>
 func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>>, %arg1: memref<512x32xvector<8xf32>>, %arg2: memref<512x32xvector<8xf32>>) {
   %num_elts = constant 256 : index
   %c0 = constant 0 : index
-  %0 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %1 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %2 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %3 = alloc() : memref<2xi32>
-  %4 = alloc() : memref<2xi32>
-  %5 = alloc() : memref<2xi32>
+  %0 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %1 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %2 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %3 = memref.alloc() : memref<2xi32>
+  %4 = memref.alloc() : memref<2xi32>
+  %5 = memref.alloc() : memref<2xi32>
   // Prologue for DMA overlap on arg2.
-  // CHECK-DAG: [[BUF_ARG2:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
-  // CHECK-DAG: [[TAG_ARG2:%[0-9]+]] = alloc() : memref<2x2xi32>
+  // CHECK-DAG: [[BUF_ARG2:%[0-9]+]] = memref.alloc() : memref<2x64x4xvector<8xf32>, 2>
+  // CHECK-DAG: [[TAG_ARG2:%[0-9]+]] = memref.alloc() : memref<2x2xi32>
   // CHECK: affine.dma_start %{{.*}}[
   // CHECK: affine.for %{{.*}} = 1 to 8 {
   affine.for %i0 = 0 to 8 {
     %6 = affine.apply #map2(%i0)
     affine.dma_start %arg2[%6, %c0], %2[%c0, %c0], %5[%c0], %num_elts : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
     affine.dma_wait %5[%c0], %num_elts : memref<2xi32>
     // Steady state for DMA overlap on arg2
     // CHECK: affine.dma_start %{{.*}}[
     // CHECK: affine.dma_wait [[TAG_ARG2]]
     // Prologue for DMA overlap on arg0, arg1 nested within i0
-    // CHECK: [[BUF_ARG0:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
-    // CHECK: [[BUF_ARG1:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
-    // CHECK: [[TAG_ARG0:%[0-9]+]] = alloc() : memref<2x2xi32>
-    // CHECK: [[TAG_ARG1:%[0-9]+]] = alloc() : memref<2x2xi32>
+    // CHECK: [[BUF_ARG0:%[0-9]+]] = memref.alloc() : memref<2x64x4xvector<8xf32>, 2>
+    // CHECK: [[BUF_ARG1:%[0-9]+]] = memref.alloc() : memref<2x64x4xvector<8xf32>, 2>
+    // CHECK: [[TAG_ARG0:%[0-9]+]] = memref.alloc() : memref<2x2xi32>
+    // CHECK: [[TAG_ARG1:%[0-9]+]] = memref.alloc() : memref<2x2xi32>
     // CHECK: affine.dma_start %{{.*}}[
     // CHECK: affine.dma_start %{{.*}}[
     // CHECK-NEXT: affine.for %{{.*}} = 1 to 8 {
     affine.for %i1 = 0 to 8 {
       %7 = affine.apply #map1(%i0, %i1)
       %8 = affine.apply #map2(%i1)
       affine.dma_start %arg0[%7, %c0], %0[%c0, %c0], %3[%c0], %num_elts : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
       affine.dma_start %arg1[%8, %c0], %1[%c0, %c0], %4[%c0], %num_elts : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
       affine.dma_wait %3[%c0], %num_elts : memref<2xi32>
       affine.dma_wait %4[%c0], %num_elts : memref<2xi32>
       // Steady state for DMA overlap on arg0, arg1
       // CHECK: affine.dma_start %{{.*}}[
       // CHECK: affine.dma_start %{{.*}}[
       // CHECK: affine.dma_wait [[TAG_ARG0]]
       // CHECK: affine.dma_wait [[TAG_ARG1]]
       // CHECK-NEXT: affine.for %{{.*}} = 0 to 4 {
       affine.for %i2 = 0 to 4 {
         "foo"() : () -> ()
       }
     }
     // epilogue for arg0, arg1
     // CHECK: affine.dma_wait [[TAG_ARG0]]
     // CHECK: affine.dma_wait [[TAG_ARG1]]
-    // CHECK-DAG:    dealloc [[TAG_ARG1]] : memref<2x2xi32>
-    // CHECK-DAG:    dealloc [[TAG_ARG0]] : memref<2x2xi32>
-    // CHECK-DAG:    dealloc [[BUF_ARG1]] : memref<2x64x4xvector<8xf32>, 2>
-    // CHECK-DAG:    dealloc [[BUF_ARG0]] : memref<2x64x4xvector<8xf32>, 2>
+    // CHECK-DAG:    memref.dealloc [[TAG_ARG1]] : memref<2x2xi32>
+    // CHECK-DAG:    memref.dealloc [[TAG_ARG0]] : memref<2x2xi32>
+    // CHECK-DAG:    memref.dealloc [[BUF_ARG1]] : memref<2x64x4xvector<8xf32>, 2>
+    // CHECK-DAG:    memref.dealloc [[BUF_ARG0]] : memref<2x64x4xvector<8xf32>, 2>
   // epilogue for DMA overlap on %arg2
   // CHECK:  affine.dma_wait [[TAG_ARG2]]
   // Within the epilogue for arg2's DMA, we have the DMAs on %arg1, %arg2 nested.
-  // CHECK: [[BUF_ARG0_NESTED:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
-  // CHECK: [[BUF_ARG1_NESTED:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
-  // CHECK: [[TAG_ARG0_NESTED:%[0-9]+]] = alloc() : memref<2x2xi32>
-  // CHECK: [[TAG_ARG1_NESTED:%[0-9]+]] = alloc() : memref<2x2xi32>
+  // CHECK: [[BUF_ARG0_NESTED:%[0-9]+]] = memref.alloc() : memref<2x64x4xvector<8xf32>, 2>
+  // CHECK: [[BUF_ARG1_NESTED:%[0-9]+]] = memref.alloc() : memref<2x64x4xvector<8xf32>, 2>
+  // CHECK: [[TAG_ARG0_NESTED:%[0-9]+]] = memref.alloc() : memref<2x2xi32>
+  // CHECK: [[TAG_ARG1_NESTED:%[0-9]+]] = memref.alloc() : memref<2x2xi32>
   // CHECK:  affine.dma_start %{{.*}}[
   // CHECK:  affine.dma_start %{{.*}}[
   // CHECK:  affine.for %{{.*}} = 1 to 8 {
   // CHECK:    affine.dma_start %{{.*}}[
   // CHECK:    affine.dma_start %{{.*}}[
   // CHECK:    affine.dma_wait [[TAG_ARG0_NESTED]]
   // CHECK:    affine.dma_wait [[TAG_ARG1_NESTED]]
   // CHECK:    affine.for %{{.*}} = 0 to 4 {
   // CHECK:      "foo"() : () -> ()
   // CHECK:  affine.dma_wait [[TAG_ARG0_NESTED]]
   // CHECK:  affine.dma_wait [[TAG_ARG1_NESTED]]
   // CHECK:  affine.for %{{.*}} = 0 to 4 {
   }
-  dealloc %5 : memref<2xi32>
-  dealloc %4 : memref<2xi32>
-  dealloc %3 : memref<2xi32>
-  dealloc %2 : memref<64x4xvector<8xf32>, 2>
-  dealloc %1 : memref<64x4xvector<8xf32>, 2>
-  dealloc %0 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %5 : memref<2xi32>
+  memref.dealloc %4 : memref<2xi32>
+  memref.dealloc %3 : memref<2xi32>
+  memref.dealloc %2 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %1 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %0 : memref<64x4xvector<8xf32>, 2>
   return
 // CHECK: }
-// CHECK-DAG:  dealloc [[TAG_ARG1_NESTED]] : memref<2x2xi32>
-// CHECK-DAG:  dealloc [[TAG_ARG0_NESTED]] : memref<2x2xi32>
-// CHECK-DAG:  dealloc [[BUF_ARG1_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
-// CHECK-DAG:  dealloc [[BUF_ARG0_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
-// CHECK-DAG:  dealloc [[TAG_ARG2]] : memref<2x2xi32>
-// CHECK-DAG:  dealloc [[BUF_ARG2]] : memref<2x64x4xvector<8xf32>, 2>
+// CHECK-DAG:  memref.dealloc [[TAG_ARG1_NESTED]] : memref<2x2xi32>
+// CHECK-DAG:  memref.dealloc [[TAG_ARG0_NESTED]] : memref<2x2xi32>
+// CHECK-DAG:  memref.dealloc [[BUF_ARG1_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
+// CHECK-DAG:  memref.dealloc [[BUF_ARG0_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
+// CHECK-DAG:  memref.dealloc [[TAG_ARG2]] : memref<2x2xi32>
+// CHECK-DAG:  memref.dealloc [[BUF_ARG2]] : memref<2x64x4xvector<8xf32>, 2>
 // CHECK-NEXT: return
 }
 
 // -----
 #map2 = affine_map<(d0) -> ((d0 * 2048) floordiv 32)>
 
 // CHECK: func @loop_dma_dependent
 func @loop_dma_dependent(%arg2: memref<512x32xvector<8xf32>>) {
   %num_elts = constant 256 : index
   %c0 = constant 0 : index
-  %0 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %1 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %2 = alloc() : memref<64x4xvector<8xf32>, 2>
-  %3 = alloc() : memref<2xi32>
-  %4 = alloc() : memref<2xi32>
-  %5 = alloc() : memref<2xi32>
+  %0 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %1 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %2 = memref.alloc() : memref<64x4xvector<8xf32>, 2>
+  %3 = memref.alloc() : memref<2xi32>
+  %4 = memref.alloc() : memref<2xi32>
+  %5 = memref.alloc() : memref<2xi32>
 
   // The two DMAs below are dependent (incoming and outgoing on the same
   // memref) in the same iteration; so no pipelining here.
   // CHECK-NOT: affine.dma_start
   // CHECK: affine.for %{{.*}} = 0 to 8 {
   affine.for %i0 = 0 to 8 {
     %6 = affine.apply #map2(%i0)
     affine.dma_start %arg2[%6, %c0], %2[%c0, %c0], %5[%c0], %num_elts : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
     affine.dma_wait %5[%c0], %num_elts : memref<2xi32>
 
     affine.dma_start %2[%c0, %c0], %arg2[%6, %c0], %5[%c0], %num_elts : memref<64x4xvector<8xf32>, 2>, memref<512x32xvector<8xf32>>, memref<2xi32>
     affine.dma_wait %5[%c0], %num_elts : memref<2xi32>
   }
-  dealloc %5 : memref<2xi32>
-  dealloc %4 : memref<2xi32>
-  dealloc %3 : memref<2xi32>
-  dealloc %2 : memref<64x4xvector<8xf32>, 2>
-  dealloc %1 : memref<64x4xvector<8xf32>, 2>
-  dealloc %0 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %5 : memref<2xi32>
+  memref.dealloc %4 : memref<2xi32>
+  memref.dealloc %3 : memref<2xi32>
+  memref.dealloc %2 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %1 : memref<64x4xvector<8xf32>, 2>
+  memref.dealloc %0 : memref<64x4xvector<8xf32>, 2>
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @escaping_use
 func @escaping_use(%arg0: memref<512 x 32 x f32>) {
   %c32 = constant 32 : index
   %num_elt = constant 512 : index
   %zero = constant 0 : index
-  %Av = alloc() : memref<32 x 32 x f32, 2>
-  %tag = alloc() : memref<1 x i32>
+  %Av = memref.alloc() : memref<32 x 32 x f32, 2>
+  %tag = memref.alloc() : memref<1 x i32>
 
   // CHECK-NOT: affine.dma_start
   // CHECK: affine.for %{{.*}} = 0 to 16 {
   affine.for %kTT = 0 to 16 {
     affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
       memref<512 x 32 x f32>,
       memref<32 x 32 x f32, 2>, memref<1 x i32>
     affine.dma_wait %tag[%zero], %num_elt : memref<1 x i32>
     // escaping use; no DMA pipelining / double buffering will be done.
     "foo"(%Av) : (memref<32 x 32 x f32, 2>) -> ()
   }
-  dealloc %tag : memref<1 x i32>
-  dealloc %Av : memref<32 x 32 x f32, 2>
+  memref.dealloc %tag : memref<1 x i32>
+  memref.dealloc %Av : memref<32 x 32 x f32, 2>
   return
 // CHECK:        "foo"(%{{[0-9]+}}) : (memref<32x32xf32, 2>) -> ()
 // CHECK:      }
 // CHECK:      return
 }
 
 // -----
 
 // CHECK-LABEL: func @escaping_tag
 func @escaping_tag(%arg0: memref<512 x 32 x f32>) {
   %c32 = constant 32 : index
   %num_elt = constant 512 : index
   %zero = constant 0 : index
-  %Av = alloc() : memref<32 x 32 x f32, 2>
-  %tag = alloc() : memref<1 x i32>
+  %Av = memref.alloc() : memref<32 x 32 x f32, 2>
+  %tag = memref.alloc() : memref<1 x i32>
 
   // CHECK-NOT: affine.dma_start
   // CHECK: affine.for %{{.*}} = 0 to 16 {
   affine.for %kTT = 0 to 16 {
     affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
       memref<512 x 32 x f32>,
       memref<32 x 32 x f32, 2>, memref<1 x i32>
     affine.dma_wait %tag[%zero], %num_elt : memref<1 x i32>
     // escaping use; no DMA pipelining / double buffering will be done.
     "foo"(%tag) : (memref<1 x i32>) -> ()
   }
-  dealloc %tag : memref<1 x i32>
-  dealloc %Av : memref<32 x 32 x f32, 2>
+  memref.dealloc %tag : memref<1 x i32>
+  memref.dealloc %Av : memref<32 x 32 x f32, 2>
   return
 // CHECK:        "foo"(%{{[0-9]+}}) : (memref<1xi32>) -> ()
 // CHECK:      }
 // CHECK:      return
 }
 
 
 // -----
 
 // CHECK-LABEL: func @live_out_use
 func @live_out_use(%arg0: memref<512 x 32 x f32>) -> f32 {
   %c32 = constant 32 : index
   %num_elt = constant 512 : index
   %zero = constant 0 : index
-  %Av = alloc() : memref<32 x 32 x f32, 2>
-  %tag = alloc() : memref<1 x i32>
+  %Av = memref.alloc() : memref<32 x 32 x f32, 2>
+  %tag = memref.alloc() : memref<1 x i32>
 
   // CHECK-NOT: affine.dma_start
   // CHECK: affine.for %{{.*}} = 0 to 16 {
   affine.for %kTT = 0 to 16 {
     affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
       memref<512 x 32 x f32>,
       memref<32 x 32 x f32, 2>, memref<1 x i32>
     affine.dma_wait %tag[%zero], %num_elt : memref<1 x i32>
   }
   // Use live out of 'affine.for' op; no DMA pipelining will be done.
   %v = affine.load %Av[%zero, %zero] : memref<32 x 32 x f32, 2>
-  dealloc %tag : memref<1 x i32>
-  dealloc %Av : memref<32 x 32 x f32, 2>
+  memref.dealloc %tag : memref<1 x i32>
+  memref.dealloc %Av : memref<32 x 32 x f32, 2>
   return %v : f32
 // CHECK:      affine.load %{{[0-9]+}}[%{{.*}}, %{{.*}}] : memref<32x32xf32, 2>
 // CHECK:      return
 }
 
 // -----
 
 // CHECK-LABEL: func @dynamic_shape_dma_buffer
 func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) {
   %c32 = constant 32 : index
   %num_elt = constant 512 : index
   %zero = constant 0 : index
 
-  %Av = alloc(%c32, %c32) : memref<? x ? x f32, 2>
-  %tag = alloc() : memref<1 x i32>
+  %Av = memref.alloc(%c32, %c32) : memref<? x ? x f32, 2>
+  %tag = memref.alloc() : memref<1 x i32>
 
 // Double buffering for dynamic shaped buffer.
-// CHECK:       alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 2>
+// CHECK:       memref.alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 2>
 // CHECK-NEXT:  %[[C0:.*]] = constant 0 : index
 // CHECK-NEXT:  dim %{{.*}}, %[[C0]] : memref<?x?xf32, 2>
 // CHECK-NEXT:  %[[C1:.*]] = constant 1 : index
 // CHECK-NEXT:  dim %{{.*}}, %[[C1]] : memref<?x?xf32, 2>
-// CHECK-NEXT:  alloc(%{{.*}}, %{{.*}}) : memref<2x?x?xf32, 2>
+// CHECK-NEXT:  memref.alloc(%{{.*}}, %{{.*}}) : memref<2x?x?xf32, 2>
 // CHECK:       affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0, 0], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}}
   affine.for %kTT = 0 to 16 {
     affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
       memref<512 x 32 x f32>,
       memref<? x ? x f32, 2>, memref<1 x i32>
     affine.dma_wait %tag[%zero], %num_elt : memref<1 x i32>
   }
-  dealloc %Av : memref<? x ? x f32, 2>
+  memref.dealloc %Av : memref<? x ? x f32, 2>
   return
 // CHECK-NEXT:  affine.for %{{.*}} = 1 to 16 {
 // CHECK:         affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0, 0], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}}
 // CHECK:         affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xi32>
 // CHECK:       }
 // CHECK:       affine.dma_wait %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<2x1xi32>
 // CHECK:       return
 }
 
 // Memref replacement will fail here due to a non-dereferencing use. However,
 // no incorrect transformation is performed in spite of one of the uses being a
 // dereferencing one since replaceAllMemRefUsesWith checks for escaping uses
 // before performing any replacement.
 // CHECK-LABEL: func @escaping_and_indexed_use_mix
 func @escaping_and_indexed_use_mix() {
-  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
-  %Ah = alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
-  %tag = alloc() : memref<1 x f32>
+  %A = memref.alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = memref.alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
+  %tag = memref.alloc() : memref<1 x f32>
   %zero = constant 0 : index
   %num_elts = constant 32 : index
 
   // alloc for the buffer is created but no replacement should happen.
   affine.for %i = 0 to 8 {
     affine.dma_start %A[%i], %Ah[%i], %tag[%zero], %num_elts : memref<256 x f32>, memref<32 x f32, 1>, memref<1 x f32>
     affine.dma_wait %tag[%zero], %num_elts : memref<1 x f32>
     "compute"(%Ah) : (memref<32 x f32, 1>) -> ()
     %v = affine.load %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     "foo"(%v) : (f32) -> ()
   }
-  dealloc %A : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
-  dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
+  memref.dealloc %A : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  memref.dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
   return
 }
 // No replacement.
 // CHECK: affine.for %{{.*}} = 0 to 8 {
 // CHECK-NEXT:   affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
 // CHECK-NEXT:   affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xf32>
 // CHECK-NEXT:   "compute"(%{{.*}}) : (memref<32xf32, 1>) -> ()
 // CHECK-NEXT:   [[VAL:%[0-9]+]] = affine.load %{{.*}}[%{{.*}}] : memref<32xf32, 1>
 // CHECK-NEXT:   "foo"([[VAL]]) : (f32) -> ()

mlir/test/Transforms/promote-buffers-to-stack.mlir

 // AllocaOp.
 
 // CHECK-LABEL: func @condBranch
 func @condBranch(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br {{.*}}
 //      CHECK: ^bb2
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  bb1  bb2 <- Initial position of AllocOp
 //   \   /
 //    bb3
 // PromoteBuffersToStack expected behavior:
 // Since the alloc has dynamic type, it is not converted into an alloca.
 
 // CHECK-LABEL: func @condBranchDynamicType
 func @condBranchDynamicType(
   %arg0: i1,
   %arg1: memref<?xf32>,
   %arg2: memref<?xf32>,
   %arg3: index) {
   cond_br %arg0, ^bb1, ^bb2(%arg3: index)
 ^bb1:
   br ^bb3(%arg1 : memref<?xf32>)
 ^bb2(%0: index):
-  %1 = alloc(%0) : memref<?xf32>
+  %1 = memref.alloc(%0) : memref<?xf32>
   test.buffer_based in(%arg1: memref<?xf32>) out(%1: memref<?xf32>)
   br ^bb3(%1 : memref<?xf32>)
 ^bb3(%2: memref<?xf32>):
   test.copy(%2, %arg2) : (memref<?xf32>, memref<?xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br
 //      CHECK: ^bb2
 //      CHECK: ^bb2(%[[IDX:.*]]:{{.*}})
-// CHECK-NEXT: %[[ALLOC0:.*]] = alloc(%[[IDX]])
+// CHECK-NEXT: %[[ALLOC0:.*]] = memref.alloc(%[[IDX]])
 // CHECK-NEXT: test.buffer_based
 //      CHECK: br ^bb3
 // CHECK-NEXT: ^bb3(%[[ALLOC0:.*]]:{{.*}})
 //      CHECK: test.copy(%[[ALLOC0]],
 // CHECK-NEXT: return
 
 // -----
 
 // CHECK-LABEL: func @dynamicRanked
 func @dynamicRanked(%tensor: tensor<*xf32>) {
   %0 = rank %tensor : tensor<*xf32>
-  %1 = alloc(%0) : memref<?xindex>
+  %1 = memref.alloc(%0) : memref<?xindex>
   return
 }
 
 // CHECK-NEXT: %[[RANK:.*]] = rank
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca(%[[RANK]])
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca(%[[RANK]])
 
 // -----
 
 // CHECK-LABEL: func @dynamicRanked2D
 func @dynamicRanked2D(%tensor: tensor<*xf32>) {
   %0 = rank %tensor : tensor<*xf32>
-  %1 = alloc(%0, %0) : memref<?x?xindex>
+  %1 = memref.alloc(%0, %0) : memref<?x?xindex>
   return
 }
 
 // CHECK-NEXT: %[[RANK:.*]] = rank
-//  RANK-NEXT: %[[ALLOC:.*]] = alloca(%[[RANK]], %[[RANK]])
-// DEFINDEX-NEXT: %[[ALLOC:.*]] = alloc(%[[RANK]], %[[RANK]])
+//  RANK-NEXT: %[[ALLOC:.*]] = memref.alloca(%[[RANK]], %[[RANK]])
+// DEFINDEX-NEXT: %[[ALLOC:.*]] = memref.alloc(%[[RANK]], %[[RANK]])
 
 // -----
 
 // CHECK-LABEL: func @dynamicNoRank
 func @dynamicNoRank(%arg0: index) {
-  %0 = alloc(%arg0) : memref<?xindex>
+  %0 = memref.alloc(%arg0) : memref<?xindex>
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc
 
 // -----
 
 // Test Case: Existing AllocOp with no users.
 // PromoteBuffersToStack expected behavior: It should convert it to an
 // AllocaOp.
 
 // CHECK-LABEL: func @emptyUsesValue
 func @emptyUsesValue(%arg0: memref<4xf32>) {
-  %0 = alloc() : memref<4xf32>
+  %0 = memref.alloc() : memref<4xf32>
   return
 }
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0
 //   /   \
 //  |    bb1 <- Initial position of AllocOp
 //   \   /
 //    bb2
 // PromoteBuffersToStack expected behavior: It should convert it into an
 // AllocaOp.
 
 // CHECK-LABEL: func @criticalEdge
 func @criticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   br ^bb2(%0 : memref<2xf32>)
 ^bb2(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br {{.*}}
 //      CHECK: ^bb1
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0 <- Initial position of AllocOp
 //   /   \
 //  |    bb1
 //   \   /
 //    bb2
 // PromoteBuffersToStack expected behavior: It converts the alloc in an alloca.
 
 // CHECK-LABEL: func @invCriticalEdge
 func @invCriticalEdge(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0, ^bb1, ^bb2(%arg1 : memref<2xf32>)
 ^bb1:
   br ^bb2(%0 : memref<2xf32>)
 ^bb2(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: cond_br
 //      CHECK: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case:
 //    bb0 <- Initial position of the first AllocOp
 //   /   \
 //  bb1  bb2
 //   \   /
 //    bb3 <- Initial position of the second AllocOp
 // PromoteBuffersToStack expected behavior: It converts the allocs into allocas.
 
 // CHECK-LABEL: func @ifElse
 func @ifElse(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
-  %7 = alloc() : memref<2xf32>
+  %7 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%5: memref<2xf32>) out(%7: memref<2xf32>)
   test.copy(%7, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA0:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOCA1:.*]] = alloca()
+//      CHECK: %[[ALLOCA1:.*]] = memref.alloca()
 //      CHECK: test.buffer_based
 //      CHECK: test.copy(%[[ALLOCA1]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: No users for buffer in if-else CFG
 //    bb0 <- Initial position of AllocOp
 //   /   \
 //  bb1  bb2
 //   \   /
 //    bb3
 // PromoteBuffersToStack expected behavior: It converts the alloc into alloca.
 
 // CHECK-LABEL: func @ifElseNoUsers
 func @ifElseNoUsers(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb3(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   br ^bb3(%3, %4 : memref<2xf32>, memref<2xf32>)
 ^bb3(%5: memref<2xf32>, %6: memref<2xf32>):
   test.copy(%arg1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: return
 
 // -----
 
 // Test Case:
 //      bb0 <- Initial position of the first AllocOp
 //     /    \
 //   bb1    bb2
 //    |     /  \
 //    |   bb3  bb4
 //    \     \  /
 //     \     /
 //       bb5 <- Initial position of the second AllocOp
 // PromoteBuffersToStack expected behavior: The two allocs should be converted
 // into allocas.
 
 // CHECK-LABEL: func @ifElseNested
 func @ifElseNested(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>)
   cond_br %arg0,
     ^bb1(%arg1, %0 : memref<2xf32>, memref<2xf32>),
     ^bb2(%0, %arg1 : memref<2xf32>, memref<2xf32>)
 ^bb1(%1: memref<2xf32>, %2: memref<2xf32>):
   br ^bb5(%1, %2 : memref<2xf32>, memref<2xf32>)
 ^bb2(%3: memref<2xf32>, %4: memref<2xf32>):
   cond_br %arg0, ^bb3(%3 : memref<2xf32>), ^bb4(%4 : memref<2xf32>)
 ^bb3(%5: memref<2xf32>):
   br ^bb5(%5, %3 : memref<2xf32>, memref<2xf32>)
 ^bb4(%6: memref<2xf32>):
   br ^bb5(%3, %6 : memref<2xf32>, memref<2xf32>)
 ^bb5(%7: memref<2xf32>, %8: memref<2xf32>):
-  %9 = alloc() : memref<2xf32>
+  %9 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%7: memref<2xf32>) out(%9: memref<2xf32>)
   test.copy(%9, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA0:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based
-//      CHECK: %[[ALLOCA1:.*]] = alloca()
+//      CHECK: %[[ALLOCA1:.*]] = memref.alloca()
 //      CHECK: test.buffer_based
 //      CHECK: test.copy(%[[ALLOCA1]]
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Dead operations in a single block.
 // PromoteBuffersToStack expected behavior: It converts the two AllocOps into
 // allocas.
 
 // CHECK-LABEL: func @redundantOperations
 func @redundantOperations(%arg0: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%0: memref<2xf32>) out(%1: memref<2xf32>)
   return
 }
 
 //      CHECK: (%[[ARG0:.*]]: {{.*}})
-// CHECK-NEXT: %[[ALLOCA0:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA0:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based in(%[[ARG0]]{{.*}} out(%[[ALLOCA0]]
-//      CHECK: %[[ALLOCA1:.*]] = alloca()
+//      CHECK: %[[ALLOCA1:.*]] = memref.alloca()
 // CHECK-NEXT: test.buffer_based in(%[[ALLOCA0]]{{.*}} out(%[[ALLOCA1]]
 //      CHECK: return
 
 // -----
 
 // Test Case:
 //                                     bb0
 //                                    /   \
 // Initial pos of the 1st AllocOp -> bb1  bb2 <- Initial pos of the 2nd AllocOp
 //                                    \   /
 //                                     bb3
 // PromoteBuffersToStack expected behavior: Both AllocOps are converted into
 // allocas.
 
 // CHECK-LABEL: func @moving_alloc_and_inserting_missing_dealloc
 func @moving_alloc_and_inserting_missing_dealloc(
   %cond: i1,
     %arg0: memref<2xf32>,
     %arg1: memref<2xf32>) {
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%0: memref<2xf32>)
   br ^exit(%0 : memref<2xf32>)
 ^bb2:
-  %1 = alloc() : memref<2xf32>
+  %1 = memref.alloc() : memref<2xf32>
   test.buffer_based in(%arg0: memref<2xf32>) out(%1: memref<2xf32>)
   br ^exit(%1 : memref<2xf32>)
 ^exit(%arg2: memref<2xf32>):
   test.copy(%arg2, %arg1) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT: cond_br {{.*}}
 //      CHECK: ^bb1
-// CHECK-NEXT: %{{.*}} = alloca()
+// CHECK-NEXT: %{{.*}} = memref.alloca()
 //      CHECK: ^bb2
-// CHECK-NEXT: %{{.*}} = alloca()
+// CHECK-NEXT: %{{.*}} = memref.alloca()
 //      CHECK: test.copy
 // CHECK-NEXT: return
 
 // -----
 
 // Test Case: Nested regions - This test defines a BufferBasedOp inside the
 // region of a RegionBufferBasedOp.
 // PromoteBuffersToStack expected behavior: The AllocOps are converted into
 // allocas.
 
 // CHECK-LABEL: func @nested_regions_and_cond_branch
 func @nested_regions_and_cond_branch(
   %arg0: i1,
   %arg1: memref<2xf32>,
   %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   test.region_buffer_based in(%arg1: memref<2xf32>) out(%0: memref<2xf32>) {
   ^bb0(%gen1_arg0: f32, %gen1_arg1: f32):
-    %1 = alloc() : memref<2xf32>
+    %1 = memref.alloc() : memref<2xf32>
     test.buffer_based in(%arg1: memref<2xf32>) out(%1: memref<2xf32>)
     %tmp1 = math.exp %gen1_arg0 : f32
     test.region_yield %tmp1 : f32
   }
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   test.copy(%1, %arg2) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
 // CHECK-NEXT:   cond_br {{.*}}
 //      CHECK:   ^bb2
-// CHECK-NEXT:   %[[ALLOCA0:.*]] = alloca()
+// CHECK-NEXT:   %[[ALLOCA0:.*]] = memref.alloca()
 //      CHECK:   ^bb0
-// CHECK-NEXT:   %[[ALLOCA1:.*]] = alloc()
+// CHECK-NEXT:   %[[ALLOCA1:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: buffer deallocation escaping
 // PromoteBuffersToStack expected behavior: The first alloc is returned, so
 // there is no conversion allowed. The second alloc is converted, since it
 // only remains in the scope of the function.
 
 // CHECK-LABEL: func @memref_in_function_results
 func @memref_in_function_results(
   %arg0: memref<5xf32>,
   %arg1: memref<10xf32>,
   %arg2: memref<5xf32>) -> (memref<10xf32>, memref<15xf32>) {
-  %x = alloc() : memref<15xf32>
-  %y = alloc() : memref<5xf32>
+  %x = memref.alloc() : memref<15xf32>
+  %y = memref.alloc() : memref<5xf32>
   test.buffer_based in(%arg0: memref<5xf32>) out(%y: memref<5xf32>)
   test.copy(%y, %arg2) : (memref<5xf32>, memref<5xf32>)
   return %arg1, %x : memref<10xf32>, memref<15xf32>
 }
 //      CHECK: (%[[ARG0:.*]]: memref<5xf32>, %[[ARG1:.*]]: memref<10xf32>,
 // CHECK-SAME: %[[RESULT:.*]]: memref<5xf32>)
-//      CHECK: %[[ALLOC:.*]] = alloc()
-//      CHECK: %[[ALLOCA:.*]] = alloca()
+//      CHECK: %[[ALLOC:.*]] = memref.alloc()
+//      CHECK: %[[ALLOCA:.*]] = memref.alloca()
 //      CHECK: test.copy
 //      CHECK: return %[[ARG1]], %[[ALLOC]]
 
 // -----
 
 // Test Case: nested region control flow
 // The allocation in the nested if branch cannot be converted to an alloca
 // due to its dynamic memory allocation behavior.
 
 // CHECK-LABEL: func @nested_region_control_flow
 func @nested_region_control_flow(
   %arg0 : index,
   %arg1 : index) -> memref<?x?xf32> {
   %0 = cmpi eq, %arg0, %arg1 : index
-  %1 = alloc(%arg0, %arg0) : memref<?x?xf32>
+  %1 = memref.alloc(%arg0, %arg0) : memref<?x?xf32>
   %2 = scf.if %0 -> (memref<?x?xf32>) {
     scf.yield %1 : memref<?x?xf32>
   } else {
-    %3 = alloc(%arg0, %arg1) : memref<?x?xf32>
+    %3 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
     scf.yield %1 : memref<?x?xf32>
   }
   return %2 : memref<?x?xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc(%arg0, %arg0)
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc(%arg0, %arg0)
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.if
 //      CHECK: scf.yield %[[ALLOC0]]
-//      CHECK: %[[ALLOC2:.*]] = alloc(%arg0, %arg1)
+//      CHECK: %[[ALLOC2:.*]] = memref.alloc(%arg0, %arg1)
 // CHECK-NEXT: scf.yield %[[ALLOC0]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: nested region control flow within a region interface.
 // The alloc %0 does not need to be converted in this case since the
 // allocation finally escapes the method.
 
 // CHECK-LABEL: func @inner_region_control_flow
 func @inner_region_control_flow(%arg0 : index) -> memref<2x2xf32> {
-  %0 = alloc() : memref<2x2xf32>
+  %0 = memref.alloc() : memref<2x2xf32>
   %1 = test.region_if %0 : memref<2x2xf32> -> (memref<2x2xf32>) then {
     ^bb0(%arg1 : memref<2x2xf32>):
       test.region_if_yield %arg1 : memref<2x2xf32>
   } else {
     ^bb0(%arg1 : memref<2x2xf32>):
       test.region_if_yield %arg1 : memref<2x2xf32>
   } join {
     ^bb0(%arg1 : memref<2x2xf32>):
       test.region_if_yield %arg1 : memref<2x2xf32>
   }
   return %1 : memref<2x2xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: %[[ALLOC1:.*]] = test.region_if
 // CHECK-NEXT: ^bb0(%[[ALLOC2:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC2]]
 //      CHECK: ^bb0(%[[ALLOC3:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC3]]
 //      CHECK: ^bb0(%[[ALLOC4:.*]]:{{.*}}):
 // CHECK-NEXT: test.region_if_yield %[[ALLOC4]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: structured control-flow loop using a nested alloc.
 // Alloc %0 will be converted to an alloca. %3 is not transformed.
 
 // CHECK-LABEL: func @loop_alloc
 func @loop_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
-    %3 = alloc() : memref<2xf32>
+    %3 = memref.alloc() : memref<2xf32>
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
+// CHECK-NEXT: %[[ALLOCA:.*]] = memref.alloca()
 // CHECK-NEXT: scf.for
-//      CHECK: %[[ALLOC:.*]] = alloc()
+//      CHECK: %[[ALLOC:.*]] = memref.alloc()
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation.
 // The loop yields buffers that have been defined outside of the loop and the
 // backedges only use the iteration arguments (or one of its aliases).
 // Therefore, we do not have to (and are not allowed to) free any buffers
 // that are passed via the backedges. The alloc is converted to an AllocaOp.
 
 // CHECK-LABEL: func @loop_nested_if_no_alloc
 func @loop_nested_if_no_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>,
   %res: memref<2xf32>) {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
       scf.yield %0 : memref<2xf32>
     } else {
       scf.yield %iterBuf : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   test.copy(%1, %res) : (memref<2xf32>, memref<2xf32>)
   return
 }
 
-//      CHECK: %[[ALLOCA0:.*]] = alloca()
+//      CHECK: %[[ALLOCA0:.*]] = memref.alloca()
 // CHECK-NEXT: %[[ALLOCA1:.*]] = scf.for {{.*}} iter_args(%[[IALLOCA:.*]] =
 //      CHECK: %[[ALLOCA2:.*]] = scf.if
 //      CHECK: scf.yield %[[ALLOCA0]]
 //      CHECK: scf.yield %[[IALLOCA]]
 //      CHECK: scf.yield %[[ALLOCA2]]
 //      CHECK: test.copy(%[[ALLOCA1]], %arg4)
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation using
 // a deeply nested buffer allocation.
 // The allocs are not converted in this case.
 
 // CHECK-LABEL: func @loop_nested_if_alloc
 func @loop_nested_if_alloc(
   %lb: index,
   %ub: index,
   %step: index,
   %buf: memref<2xf32>) -> memref<2xf32> {
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   %1 = scf.for %i = %lb to %ub step %step
     iter_args(%iterBuf = %buf) -> memref<2xf32> {
     %2 = cmpi eq, %i, %ub : index
     %3 = scf.if %2 -> (memref<2xf32>) {
-      %4 = alloc() : memref<2xf32>
+      %4 = memref.alloc() : memref<2xf32>
       scf.yield %4 : memref<2xf32>
     } else {
       scf.yield %0 : memref<2xf32>
     }
     scf.yield %3 : memref<2xf32>
   }
   return %1 : memref<2xf32>
 }
 
-//      CHECK: %[[ALLOC0:.*]] = alloc()
+//      CHECK: %[[ALLOC0:.*]] = memref.alloc()
 // CHECK-NEXT: %[[ALLOC1:.*]] = scf.for {{.*}}
 //      CHECK: %[[ALLOC2:.*]] = scf.if
-//      CHECK: %[[ALLOC3:.*]] = alloc()
+//      CHECK: %[[ALLOC3:.*]] = memref.alloc()
 // CHECK-NEXT: scf.yield %[[ALLOC3]]
 //      CHECK: scf.yield %[[ALLOC0]]
 //      CHECK: scf.yield %[[ALLOC2]]
 //      CHECK: return %[[ALLOC1]]
 
 // -----
 
 // Test Case: The allocated buffer is too large and, hence, it is not
 // converted. In the actual implementation the largest size is 1KB.
 
 // CHECK-LABEL: func @large_buffer_allocation
 func @large_buffer_allocation(%arg0: memref<2048xf32>) {
-  %0 = alloc() : memref<2048xf32>
+  %0 = memref.alloc() : memref<2048xf32>
   test.copy(%0, %arg0) : (memref<2048xf32>, memref<2048xf32>)
   return
 }
 
-// CHECK-NEXT: %[[ALLOC:.*]] = alloc()
+// CHECK-NEXT: %[[ALLOC:.*]] = memref.alloc()
 // CHECK-NEXT: test.copy
 
 // -----
 
 // Test Case: AllocOp with element type index.
 // PromoteBuffersToStack expected behavior: It should convert it to an
 // AllocaOp.
 
 // CHECK-LABEL: func @indexElementType
 func @indexElementType() {
-  %0 = alloc() : memref<4xindex>
+  %0 = memref.alloc() : memref<4xindex>
   return
 }
-// DEFINDEX-NEXT: alloca()
-// BIGINDEX-NEXT: alloca()
-// LOWLIMIT-NEXT: alloc()
-// RANK-NEXT: alloca()
+// DEFINDEX-NEXT: memref.alloca()
+// BIGINDEX-NEXT: memref.alloca()
+// LOWLIMIT-NEXT: memref.alloc()
+// RANK-NEXT: memref.alloca()
 // CHECK-NEXT: return

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

 //===----------------------------------------------------------------------===//
 
 // Allocation call back
 static Optional<Value> allocCallBackFn(OpBuilder &b, SubViewOp subView,
                                        ArrayRef<Value> boundingSubViewSize,
                                        OperationFolder *folder) {
   SmallVector<int64_t, 4> shape(boundingSubViewSize.size(), -1);
   return b
-      .create<AllocOp>(subView.getLoc(),
-                       MemRefType::get(shape,
-                                       subView.getType().getElementType(),
-                                       /*affineMapComposition =*/{}, 3),
-                       boundingSubViewSize)
+      .create<memref::AllocOp>(
+          subView.getLoc(),
+          MemRefType::get(shape, subView.getType().getElementType(),
       .getResult();
 }
 
 // Deallocation callback
 static LogicalResult deallocCallBackFn(OpBuilder &b, Value buffer) {
-  b.create<DeallocOp>(buffer.getLoc(), buffer);
+  b.create<memref::DeallocOp>(buffer.getLoc(), buffer);
   return success();
 }
 
 // Copy in call back
 static LogicalResult copyCallBackFn(OpBuilder &b, Value src, Value dst,
                                     bool isOutput) {
   auto floatType = src.getType().cast<MemRefType>().getElementType();
   if (!floatType.isa<FloatType>())

mlir/test/lib/Transforms/TestMemRefStrideCalculation.cpp

 //===- TestMemRefStrideCalculation.cpp - Pass to test strides computation--===//
 //
 // 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/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 struct TestMemRefStrideCalculation
     : public PassWrapper<TestMemRefStrideCalculation, FunctionPass> {
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 /// Traverse AllocOp and compute strides of each MemRefType independently.
 void TestMemRefStrideCalculation::runOnFunction() {
   llvm::outs() << "Testing: " << getFunction().getName() << "\n";
-  getFunction().walk([&](AllocOp allocOp) {
+  getFunction().walk([&](memref::AllocOp allocOp) {
     auto memrefType = allocOp.getResult().getType().cast<MemRefType>();
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     if (failed(getStridesAndOffset(memrefType, strides, offset))) {
       llvm::outs() << "MemRefType " << memrefType << " cannot be converted to "
                    << "strided form\n";
       return;
     }

mlir/test/lib/Transforms/TestVectorTransforms.cpp

 //===- TestVectorToVectorConversion.cpp - Test VectorTransfers lowering ---===//
 //
 // 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 <type_traits>
 
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Dialect/Vector/VectorTransforms.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
void runOnFunction() override {
     FuncOp func = getFunction();
     func.walk([&](AddFOp op) {
       // Check that the operation type can be broken down into a loop.
       VectorType type = op.getType().dyn_cast<VectorType>();
       if (!type || type.getRank() != 1 ||
           type.getNumElements() % multiplicity != 0)
         return mlir::WalkResult::advance();
       auto filterAlloc = [](Operation *op) {
-        if (isa<ConstantOp, AllocOp, CallOp>(op))
+        if (isa<ConstantOp, memref::AllocOp, CallOp>(op))
           return false;
         return true;
       };
       auto dependentOps = getSlice(op, filterAlloc);
       // Create a loop and move instructions from the Op slice into the loop.
       OpBuilder builder(op);
       auto zero = builder.create<ConstantOp>(
           op.getLoc(), builder.getIndexType(),

mlir/test/mlir-cpu-runner/async-value.mlir

func @main() {
 
   // CHECK: 456.789
   vector.print %4 : f32
 
   // ------------------------------------------------------------------------ //
   // Memref allocated inside async.execute region.
   // ------------------------------------------------------------------------ //
   %token2, %result2 = async.execute[%token0] -> !async.value<memref<f32>> {
-    %5 = alloc() : memref<f32>
+    %5 = memref.alloc() : memref<f32>
     %c0 = constant 0.25 : f32
-    store %c0, %5[]: memref<f32>
+    memref.store %c0, %5[]: memref<f32>
     async.yield %5 : memref<f32>
   }
   %6 = async.await %result2 : !async.value<memref<f32>>
-  %7 = memref_cast %6 :  memref<f32> to memref<*xf32>
+  %7 = memref.cast %6 :  memref<f32> to memref<*xf32>
 
   // CHECK: Unranked Memref
   // CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
   // CHECK-NEXT: [0.25]
   call @print_memref_f32(%7): (memref<*xf32>) -> ()
 
   // ------------------------------------------------------------------------ //
   // Memref passed as async.execute operand.
   // ------------------------------------------------------------------------ //
   %token3 = async.execute(%result2 as %unwrapped : !async.value<memref<f32>>) {
     %8 = load %unwrapped[]: memref<f32>
     %9 = addf %8, %8 : f32
-    store %9, %unwrapped[]: memref<f32>
+    memref.store %9, %unwrapped[]: memref<f32>
     async.yield
   }
   async.await %token3 : !async.token
 
   // CHECK: Unranked Memref
   // CHECK-SAME: rank = 0 offset = 0 sizes = [] strides = []
   // CHECK-NEXT: [0.5]
   call @print_memref_f32(%7): (memref<*xf32>) -> ()
 
-  dealloc %6 : memref<f32>
+  memref.dealloc %6 : memref<f32>
 
   return
 }
 
 func private @print_memref_f32(memref<*xf32>)
   attributes { llvm.emit_c_interface }

mlir/test/mlir-cpu-runner/async.mlir

func @main() {
   %i3 = constant 3 : index
 
   %c0 = constant 0.0 : f32
   %c1 = constant 1.0 : f32
   %c2 = constant 2.0 : f32
   %c3 = constant 3.0 : f32
   %c4 = constant 4.0 : f32
 
-  %A = alloc() : memref<4xf32>
+  %A = memref.alloc() : memref<4xf32>
   linalg.fill(%A, %c0) : memref<4xf32>, f32
 
   // CHECK: [0, 0, 0, 0]
-  %U = memref_cast %A :  memref<4xf32> to memref<*xf32>
+  %U = memref.cast %A :  memref<4xf32> to memref<*xf32>
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
   // CHECK: Current thread id: [[MAIN:.*]]
   // CHECK: [1, 0, 0, 0]
-  store %c1, %A[%i0]: memref<4xf32>
+  memref.store %c1, %A[%i0]: memref<4xf32>
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
   %outer = async.execute {
     // CHECK: Current thread id: [[THREAD0:.*]]
     // CHECK: [1, 2, 0, 0]
-    store %c2, %A[%i1]: memref<4xf32>
+    memref.store %c2, %A[%i1]: memref<4xf32>
     call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
     call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
     // No op async region to create a token for testing async dependency.
     %noop = async.execute {
       // CHECK: Current thread id: [[THREAD1:.*]]
       call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
       async.yield
     }
 
     %inner = async.execute [%noop] {
       // CHECK: Current thread id: [[THREAD2:.*]]
       // CHECK: [1, 2, 3, 0]
-      store %c3, %A[%i2]: memref<4xf32>
+      memref.store %c3, %A[%i2]: memref<4xf32>
       call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
       call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
       async.yield
     }
     async.await %inner : !async.token
 
     // CHECK: Current thread id: [[THREAD3:.*]]
     // CHECK: [1, 2, 3, 4]
-    store %c4, %A[%i3]: memref<4xf32>
+    memref.store %c4, %A[%i3]: memref<4xf32>
     call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
     call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
     async.yield
   }
   async.await %outer : !async.token
 
   // CHECK: Current thread id: [[MAIN]]
   // CHECK: [1, 2, 3, 4]
   call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
 
-  dealloc %A : memref<4xf32>
+  memref.dealloc %A : memref<4xf32>
 
   return
 }
 
 func private @mlirAsyncRuntimePrintCurrentThreadId() -> ()
 
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }

mlir/test/mlir-cpu-runner/bare_ptr_call_conv.mlir

 // RUN: mlir-opt %s -convert-scf-to-std -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
 
 // Verify bare pointer memref calling convention. `simple_add1_add2_test`
 // gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second
 // one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2}
 // and {4, 4} are the expected outputs.
 
 func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %cst = constant 1.000000e+00 : f32
   %cst_0 = constant 2.000000e+00 : f32
   scf.for %arg2 = %c0 to %c2 step %c1 {
     %0 = load %arg0[%arg2] : memref<2xf32>
     %1 = addf %0, %cst : f32
-    store %1, %arg0[%arg2] : memref<2xf32>
+    memref.store %1, %arg0[%arg2] : memref<2xf32>
     // CHECK: 2, 2
 
     %2 = load %arg1[%arg2] : memref<2xf32>
     %3 = addf %1, %cst_0 : f32
-    store %3, %arg1[%arg2] : memref<2xf32>
+    memref.store %3, %arg1[%arg2] : memref<2xf32>
     // CHECK-NEXT: 4, 4
   }
   return
 }
 
 // External declarations.
 llvm.func @malloc(i64) -> !llvm.ptr<i8>
 llvm.func @free(!llvm.ptr<i8>)
 func private @printF32(%arg0: f32)
 func private @printComma()
 func private @printNewline()
 
 func @main()
 {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %cst = constant 1.000000e+00 : f32
   %cst_0 = constant 2.000000e+00 : f32
-  %a = alloc() : memref<2xf32>
-  %b = alloc() : memref<2xf32>
+  %a = memref.alloc() : memref<2xf32>
+  %b = memref.alloc() : memref<2xf32>
   scf.for %i = %c0 to %c2 step %c1 {
-    store %cst, %a[%i] : memref<2xf32>
-    store %cst, %b[%i] : memref<2xf32>
+    memref.store %cst, %a[%i] : memref<2xf32>
+    memref.store %cst, %b[%i] : memref<2xf32>
   }
 
   call @simple_add1_add2_test(%a, %b) : (memref<2xf32>, memref<2xf32>) -> ()
 
   %l0 = load %a[%c0] : memref<2xf32>
   call @printF32(%l0) : (f32) -> ()
   call @printComma() : () -> ()
   %l1 = load %a[%c1] : memref<2xf32>
   call @printF32(%l1) : (f32) -> ()
   call @printNewline() : () -> ()
 
   %l2 = load %b[%c0] : memref<2xf32>
   call @printF32(%l2) : (f32) -> ()
   call @printComma() : () -> ()
   %l3 = load %b[%c1] : memref<2xf32>
   call @printF32(%l3) : (f32) -> ()
   call @printNewline() : () -> ()
 
-  dealloc %a : memref<2xf32>
-  dealloc %b : memref<2xf32>
+  memref.dealloc %a : memref<2xf32>
+  memref.dealloc %b : memref<2xf32>
   return
 }

mlir/test/mlir-cpu-runner/global_memref.mlir

 // RUN: mlir-opt %s -convert-std-to-llvm | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
 
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
 func private @print_memref_i32(memref<*xi32>) attributes { llvm.emit_c_interface }
 func private @printNewline() -> ()
 
-global_memref "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]>
+memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]>
 func @test1DMemref() {
-  %0 = get_global_memref @gv0 : memref<4xf32>
-  %U = memref_cast %0 : memref<4xf32> to memref<*xf32>
+  %0 = memref.get_global @gv0 : memref<4xf32>
+  %U = memref.cast %0 : memref<4xf32> to memref<*xf32>
   // CHECK: rank = 1
   // CHECK: offset = 0
   // CHECK: sizes = [4]
   // CHECK: strides = [1]
   // CHECK: [0,  1,  2,  3]
   call @print_memref_f32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
 
   // Overwrite some of the elements.
   %c0 = constant 0 : index
   %c2 = constant 2 : index
   %fp0 = constant 4.0 : f32
   %fp1 = constant 5.0 : f32
-  store %fp0, %0[%c0] : memref<4xf32>
-  store %fp1, %0[%c2] : memref<4xf32>
+  memref.store %fp0, %0[%c0] : memref<4xf32>
+  memref.store %fp1, %0[%c2] : memref<4xf32>
   // CHECK: rank = 1
   // CHECK: offset = 0
   // CHECK: sizes = [4]
   // CHECK: strides = [1]
   // CHECK: [4,  1,  5,  3]
   call @print_memref_f32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
-global_memref constant @gv1 : memref<3x2xi32> = dense<[[0, 1],[2, 3],[4, 5]]>
+memref.global constant @gv1 : memref<3x2xi32> = dense<[[0, 1],[2, 3],[4, 5]]>
 func @testConstantMemref() {
-  %0 = get_global_memref @gv1 : memref<3x2xi32>
-  %U = memref_cast %0 : memref<3x2xi32> to memref<*xi32>
+  %0 = memref.get_global @gv1 : memref<3x2xi32>
+  %U = memref.cast %0 : memref<3x2xi32> to memref<*xi32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [3, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   1]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
   call @print_memref_i32(%U) : (memref<*xi32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
-global_memref "private" @gv2 : memref<4x2xf32> = dense<[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0], [6.0, 7.0]]>
+memref.global "private" @gv2 : memref<4x2xf32> = dense<[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0], [6.0, 7.0]]>
 func @test2DMemref() {
-  %0 = get_global_memref @gv2 : memref<4x2xf32>
-  %U = memref_cast %0 : memref<4x2xf32> to memref<*xf32>
+  %0 = memref.get_global @gv2 : memref<4x2xf32>
+  %U = memref.cast %0 : memref<4x2xf32> to memref<*xf32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [4, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   1]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
   // CHECK: [6,   7]
   call @print_memref_f32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
 
   // Overwrite the 1.0 (at index [0, 1]) with 10.0
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %fp10 = constant 10.0 : f32
-  store %fp10, %0[%c0, %c1] : memref<4x2xf32>
+  memref.store %fp10, %0[%c0, %c1] : memref<4x2xf32>
   // CHECK: rank = 2
   // CHECK: offset = 0
   // CHECK: sizes = [4, 2]
   // CHECK: strides = [2, 1]
   // CHECK: [0,   10]
   // CHECK: [2,   3]
   // CHECK: [4,   5]
   // CHECK: [6,   7]
   call @print_memref_f32(%U) : (memref<*xf32>) -> ()
   call @printNewline() : () -> ()
   return
 }
 
-global_memref @gv3 : memref<i32> = dense<11>
+memref.global @gv3 : memref<i32> = dense<11>
 func @testScalarMemref() {
-  %0 = get_global_memref @gv3 : memref<i32>
-  %U = memref_cast %0 : memref<i32> to memref<*xi32>
+  %0 = memref.get_global @gv3 : memref<i32>
+  %U = memref.cast %0 : memref<i32> to memref<*xi32>
   // CHECK: rank = 0
   // CHECK: offset = 0
   // CHECK: sizes = []
   // CHECK: strides = []
   // CHECK: [11]
   call @print_memref_i32(%U) : (memref<*xi32>) -> ()
   call @printNewline() : () -> ()
   return

mlir/test/mlir-cpu-runner/memref_reinterpret_cast.mlir

 // RUN: mlir-opt %s -convert-scf-to-std -convert-std-to-llvm \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func @main() -> () {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
 
   // Initialize input.
-  %input = alloc() : memref<2x3xf32>
+  %input = memref.alloc() : memref<2x3xf32>
   %dim_x = dim %input, %c0 : memref<2x3xf32>
   %dim_y = dim %input, %c1 : memref<2x3xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%dim_x, %dim_y) step (%c1, %c1) {
     %prod = muli %i,  %dim_y : index
     %val = addi %prod, %j : index
     %val_i64 = index_cast %val : index to i64
     %val_f32 = sitofp %val_i64 : i64 to f32
-    store %val_f32, %input[%i, %j] : memref<2x3xf32>
+    memref.store %val_f32, %input[%i, %j] : memref<2x3xf32>
   }
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   // Test cases.
   call @cast_ranked_memref_to_static_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_ranked_memref_to_dynamic_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_unranked_memref_to_static_shape(%input) : (memref<2x3xf32>) -> ()
   call @cast_unranked_memref_to_dynamic_shape(%input) : (memref<2x3xf32>) -> ()
   return
 }
 
 func @cast_ranked_memref_to_static_shape(%input : memref<2x3xf32>) {
   %output = memref_reinterpret_cast %input to
            offset: [0], sizes: [6, 1], strides: [1, 1]
            : memref<2x3xf32> to memref<6x1xf32>
 
-  %unranked_output = memref_cast %output
+  %unranked_output = memref.cast %output
       : memref<6x1xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [6, 1] strides = [1, 1] data =
   // CHECK-NEXT: [0],
   // CHECK-NEXT: [1],
   // CHECK-NEXT: [2],
   // CHECK-NEXT: [3],
   // CHECK-NEXT: [4],
   // CHECK-NEXT: [5]
   return
 }
 
 func @cast_ranked_memref_to_dynamic_shape(%input : memref<2x3xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c6 = constant 6 : index
   %output = memref_reinterpret_cast %input to
            offset: [%c0], sizes: [%c1, %c6], strides: [%c6, %c1]
            : memref<2x3xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]>
 
-  %unranked_output = memref_cast %output
+  %unranked_output = memref.cast %output
       : memref<?x?xf32, offset: ?, strides: [?, ?]> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [1, 6] strides = [6, 1] data =
   // CHECK-NEXT: [0,   1,   2,   3,   4,   5]
   return
 }
 
 func @cast_unranked_memref_to_static_shape(%input : memref<2x3xf32>) {
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %output = memref_reinterpret_cast %unranked_input to
            offset: [0], sizes: [6, 1], strides: [1, 1]
            : memref<*xf32> to memref<6x1xf32>
 
-  %unranked_output = memref_cast %output
+  %unranked_output = memref.cast %output
       : memref<6x1xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [6, 1] strides = [1, 1] data =
   // CHECK-NEXT: [0],
   // CHECK-NEXT: [1],
   // CHECK-NEXT: [2],
   // CHECK-NEXT: [3],
   // CHECK-NEXT: [4],
   // CHECK-NEXT: [5]
   return
 }
 
 func @cast_unranked_memref_to_dynamic_shape(%input : memref<2x3xf32>) {
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c6 = constant 6 : index
   %output = memref_reinterpret_cast %unranked_input to
            offset: [%c0], sizes: [%c1, %c6], strides: [%c6, %c1]
            : memref<*xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]>
 
-  %unranked_output = memref_cast %output
+  %unranked_output = memref.cast %output
       : memref<?x?xf32, offset: ?, strides: [?, ?]> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [1, 6] strides = [6, 1] data =
   // CHECK-NEXT: [0,   1,   2,   3,   4,   5]
   return
 }

mlir/test/mlir-cpu-runner/memref_reshape.mlir

 // RUN: mlir-opt %s -convert-scf-to-std -std-expand -convert-std-to-llvm \
 // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
 // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
 // RUN: | FileCheck %s
 
 
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func @main() -> () {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
 
   // Initialize input.
-  %input = alloc() : memref<2x3xf32>
+  %input = memref.alloc() : memref<2x3xf32>
   %dim_x = dim %input, %c0 : memref<2x3xf32>
   %dim_y = dim %input, %c1 : memref<2x3xf32>
   scf.parallel (%i, %j) = (%c0, %c0) to (%dim_x, %dim_y) step (%c1, %c1) {
     %prod = muli %i,  %dim_y : index
     %val = addi %prod, %j : index
     %val_i64 = index_cast %val : index to i64
     %val_f32 = sitofp %val_i64 : i64 to f32
-    store %val_f32, %input[%i, %j] : memref<2x3xf32>
+    memref.store %val_f32, %input[%i, %j] : memref<2x3xf32>
   }
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_input) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [2, 3] strides = [3, 1]
   // CHECK-NEXT: [0,   1,   2]
   // CHECK-NEXT: [3,   4,   5]
 
   // Initialize shape.
-  %shape = alloc() : memref<2xindex>
+  %shape = memref.alloc() : memref<2xindex>
   %c2 = constant 2 : index
   %c3 = constant 3 : index
-  store %c3, %shape[%c0] : memref<2xindex>
-  store %c2, %shape[%c1] : memref<2xindex>
+  memref.store %c3, %shape[%c0] : memref<2xindex>
+  memref.store %c2, %shape[%c1] : memref<2xindex>
 
   // Test cases.
   call @reshape_ranked_memref_to_ranked(%input, %shape)
     : (memref<2x3xf32>, memref<2xindex>) -> ()
   call @reshape_unranked_memref_to_ranked(%input, %shape)
     : (memref<2x3xf32>, memref<2xindex>) -> ()
   call @reshape_ranked_memref_to_unranked(%input, %shape)
     : (memref<2x3xf32>, memref<2xindex>) -> ()
   call @reshape_unranked_memref_to_unranked(%input, %shape)
     : (memref<2x3xf32>, memref<2xindex>) -> ()
   return
 }
 
 func @reshape_ranked_memref_to_ranked(%input : memref<2x3xf32>,
                                       %shape : memref<2xindex>) {
   %output = memref_reshape %input(%shape)
                 : (memref<2x3xf32>, memref<2xindex>) -> memref<?x?xf32>
 
-  %unranked_output = memref_cast %output : memref<?x?xf32> to memref<*xf32>
+  %unranked_output = memref.cast %output : memref<?x?xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func @reshape_unranked_memref_to_ranked(%input : memref<2x3xf32>,
                                         %shape : memref<2xindex>) {
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
   %output = memref_reshape %input(%shape)
                 : (memref<2x3xf32>, memref<2xindex>) -> memref<?x?xf32>
 
-  %unranked_output = memref_cast %output : memref<?x?xf32> to memref<*xf32>
+  %unranked_output = memref.cast %output : memref<?x?xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func @reshape_ranked_memref_to_unranked(%input : memref<2x3xf32>,
                                         %shape : memref<2xindex>) {
-  %dyn_size_shape = memref_cast %shape : memref<2xindex> to memref<?xindex>
+  %dyn_size_shape = memref.cast %shape : memref<2xindex> to memref<?xindex>
   %output = memref_reshape %input(%dyn_size_shape)
                 : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
 
   call @print_memref_f32(%output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }
 
 func @reshape_unranked_memref_to_unranked(%input : memref<2x3xf32>,
                                           %shape : memref<2xindex>) {
-  %unranked_input = memref_cast %input : memref<2x3xf32> to memref<*xf32>
-  %dyn_size_shape = memref_cast %shape : memref<2xindex> to memref<?xindex>
+  %unranked_input = memref.cast %input : memref<2x3xf32> to memref<*xf32>
+  %dyn_size_shape = memref.cast %shape : memref<2xindex> to memref<?xindex>
   %output = memref_reshape %input(%dyn_size_shape)
                 : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
 
   call @print_memref_f32(%output) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1] data =
   // CHECK: [0,   1],
   // CHECK: [2,   3],
   // CHECK: [4,   5]
   return
 }

mlir/test/mlir-cpu-runner/sgemm_naive_codegen.mlir

 // RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
 
 func @main() {
-  %A = alloc() : memref<16x16xf32>
-  %B = alloc() : memref<16x16xf32>
-  %C = alloc() : memref<16x16xf32>
+  %A = memref.alloc() : memref<16x16xf32>
+  %B = memref.alloc() : memref<16x16xf32>
+  %C = memref.alloc() : memref<16x16xf32>
 
   %cf1 = constant 1.00000e+00 : f32
 
   linalg.fill(%A, %cf1) : memref<16x16xf32>, f32
   linalg.fill(%B, %cf1) : memref<16x16xf32>, f32
 
   %reps = constant 1 : index
 
func @main() {
   return
 }
 // CHECK: 17
 
 func @sgemm_naive(%arg0: memref<16x16xf32>, %arg1: memref<16x16xf32>, %arg2: memref<16x16xf32>) {
   %c0 = constant 0 : index
   affine.for %arg3 = 0 to 16 {
     affine.for %arg4 = 0 to 16 {
-      %m = alloc() : memref<1xf32>
+      %m = memref.alloc() : memref<1xf32>
       %v = affine.load %arg2[%arg3, %arg4] : memref<16x16xf32>
       affine.store %v, %m[%c0] : memref<1xf32>
       affine.for %arg5 = 0 to 16 {
         %3 = affine.load %arg0[%arg3, %arg5] : memref<16x16xf32>
         %4 = affine.load %arg1[%arg5, %arg4] : memref<16x16xf32>
         %5 = affine.load %m[0] : memref<1xf32>
         %6 = mulf %3, %4 : f32
         %7 = addf %6, %5 : f32
         affine.store %7, %m[0] : memref<1xf32>
       }
       %s = affine.load %m[%c0] : memref<1xf32>
       affine.store %s, %arg2[%arg3, %arg4] : memref<16x16xf32>
-      dealloc %m : memref<1xf32>
+      memref.dealloc %m : memref<1xf32>
     }
   }
   return
 }
 
 func private @print_flops(f64)
 func private @rtclock() -> f64

mlir/test/mlir-cpu-runner/unranked_memref.mlir

 // CHECK-SAME: strides = [3, 1]
 // CHECK-COUNT-4: [1, 1, 1]
 //
 // CHECK: rank = 2
 // CHECK-SAME: sizes = [4, 3]
 // CHECK-SAME: strides = [3, 1]
 // CHECK-COUNT-4: [1, 1, 1]
 func @main() -> () {
-    %A = alloc() : memref<10x3xf32, 0>
+    %A = memref.alloc() : memref<10x3xf32, 0>
     %f2 = constant 2.00000e+00 : f32
     %f5 = constant 5.00000e+00 : f32
     %f10 = constant 10.00000e+00 : f32
 
-    %V = memref_cast %A : memref<10x3xf32, 0> to memref<?x?xf32>
+    %V = memref.cast %A : memref<10x3xf32, 0> to memref<?x?xf32>
     linalg.fill(%V, %f10) : memref<?x?xf32, 0>, f32
-    %U = memref_cast %A : memref<10x3xf32, 0> to memref<*xf32>
+    %U = memref.cast %A : memref<10x3xf32, 0> to memref<*xf32>
     call @print_memref_f32(%U) : (memref<*xf32>) -> ()
 
-    %V2 = memref_cast %U : memref<*xf32> to memref<?x?xf32>
+    %V2 = memref.cast %U : memref<*xf32> to memref<?x?xf32>
     linalg.fill(%V2, %f5) : memref<?x?xf32, 0>, f32
-    %U2 = memref_cast %V2 : memref<?x?xf32, 0> to memref<*xf32>
+    %U2 = memref.cast %V2 : memref<?x?xf32, 0> to memref<*xf32>
     call @print_memref_f32(%U2) : (memref<*xf32>) -> ()
 
-    %V3 = memref_cast %V2 : memref<?x?xf32> to memref<*xf32>
-    %V4 = memref_cast %V3 : memref<*xf32> to memref<?x?xf32>
+    %V3 = memref.cast %V2 : memref<?x?xf32> to memref<*xf32>
+    %V4 = memref.cast %V3 : memref<*xf32> to memref<?x?xf32>
     linalg.fill(%V4, %f2) : memref<?x?xf32, 0>, f32
-    %U3 = memref_cast %V2 : memref<?x?xf32> to memref<*xf32>
+    %U3 = memref.cast %V2 : memref<?x?xf32> to memref<*xf32>
     call @print_memref_f32(%U3) : (memref<*xf32>) -> ()
 
     // 122 is ASCII for 'z'.
     %i8_z = constant 122 : i8
-    %I8 = alloc() : memref<i8>
-    store %i8_z, %I8[]: memref<i8>
-    %U4 = memref_cast %I8 : memref<i8> to memref<*xi8>
+    %I8 = memref.alloc() : memref<i8>
+    memref.store %i8_z, %I8[]: memref<i8>
+    %U4 = memref.cast %I8 : memref<i8> to memref<*xi8>
     call @print_memref_i8(%U4) : (memref<*xi8>) -> ()
 
-    dealloc %A : memref<10x3xf32, 0>
+    memref.dealloc %A : memref<10x3xf32, 0>
 
     call @return_var_memref_caller() : () -> ()
     call @return_two_var_memref_caller() : () -> ()
     call @dim_op_of_unranked() : () -> ()
     return
 }
 
 func private @print_memref_i8(memref<*xi8>) attributes { llvm.emit_c_interface }
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 func @return_two_var_memref_caller() {
-  %0 = alloca() : memref<4x3xf32>
+  %0 = memref.alloca() : memref<4x3xf32>
   %c0f32 = constant 1.0 : f32
   linalg.fill(%0, %c0f32) : memref<4x3xf32>, f32
   %1:2 = call @return_two_var_memref(%0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>)
   call @print_memref_f32(%1#0) : (memref<*xf32>) -> ()
   call @print_memref_f32(%1#1) : (memref<*xf32>) -> ()
   return
  }
 
  func @return_two_var_memref(%arg0: memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) {
-  %0 = memref_cast %arg0 : memref<4x3xf32> to memref<*xf32>
+  %0 = memref.cast %arg0 : memref<4x3xf32> to memref<*xf32>
   return %0, %0 : memref<*xf32>, memref<*xf32>
 }
 
 func @return_var_memref_caller() {
-  %0 = alloca() : memref<4x3xf32>
+  %0 = memref.alloca() : memref<4x3xf32>
   %c0f32 = constant 1.0 : f32
   linalg.fill(%0, %c0f32) : memref<4x3xf32>, f32
   %1 = call @return_var_memref(%0) : (memref<4x3xf32>) -> memref<*xf32>
   call @print_memref_f32(%1) : (memref<*xf32>) -> ()
   return
 }
 
 func @return_var_memref(%arg0: memref<4x3xf32>) -> memref<*xf32> {
-  %0 = memref_cast %arg0: memref<4x3xf32> to memref<*xf32>
+  %0 = memref.cast %arg0: memref<4x3xf32> to memref<*xf32>
   return %0 : memref<*xf32>
 }
 
 func private @printU64(index) -> ()
 func private @printNewline() -> ()
 
 func @dim_op_of_unranked() {
-  %ranked = alloc() : memref<4x3xf32>
-  %unranked = memref_cast %ranked: memref<4x3xf32> to memref<*xf32>
+  %ranked = memref.alloc() : memref<4x3xf32>
+  %unranked = memref.cast %ranked: memref<4x3xf32> to memref<*xf32>
 
   %c0 = constant 0 : index
   %dim_0 = dim %unranked, %c0 : memref<*xf32>
   call @printU64(%dim_0) : (index) -> ()
   call @printNewline() : () -> ()
   // CHECK: 4
 
   %c1 = constant 1 : index
   %dim_1 = dim %unranked, %c1 : memref<*xf32>
   call @printU64(%dim_1) : (index) -> ()
   call @printNewline() : () -> ()
   // CHECK: 3
 
   return
 }

mlir/test/mlir-cpu-runner/utils.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
 
 func @print_0d() {
   %f = constant 2.00000e+00 : f32
-  %A = alloc() : memref<f32>
-  store %f, %A[]: memref<f32>
-  %U = memref_cast %A :  memref<f32> to memref<*xf32>
+  %A = memref.alloc() : memref<f32>
+  memref.store %f, %A[]: memref<f32>
+  %U = memref.cast %A :  memref<f32> to memref<*xf32>
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
-  dealloc %A : memref<f32>
+  memref.dealloc %A : memref<f32>
   return
 }
 // PRINT-0D: Unranked Memref base@ = {{.*}} rank = 0 offset = 0 sizes = [] strides = [] data =
 // PRINT-0D: [2]
 
 func @print_1d() {
   %f = constant 2.00000e+00 : f32
-  %A = alloc() : memref<16xf32>
-  %B = memref_cast %A: memref<16xf32> to memref<?xf32>
+  %A = memref.alloc() : memref<16xf32>
+  %B = memref.cast %A: memref<16xf32> to memref<?xf32>
   linalg.fill(%B, %f) : memref<?xf32>, f32
-  %U = memref_cast %B :  memref<?xf32> to memref<*xf32>
+  %U = memref.cast %B :  memref<?xf32> to memref<*xf32>
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
-  dealloc %A : memref<16xf32>
+  memref.dealloc %A : memref<16xf32>
   return
 }
 // PRINT-1D: Unranked Memref base@ = {{.*}} rank = 1 offset = 0 sizes = [16] strides = [1] data =
 // PRINT-1D-NEXT: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
 
 func @print_3d() {
   %f = constant 2.00000e+00 : f32
   %f4 = constant 4.00000e+00 : f32
-  %A = alloc() : memref<3x4x5xf32>
-  %B = memref_cast %A: memref<3x4x5xf32> to memref<?x?x?xf32>
+  %A = memref.alloc() : memref<3x4x5xf32>
+  %B = memref.cast %A: memref<3x4x5xf32> to memref<?x?x?xf32>
   linalg.fill(%B, %f) : memref<?x?x?xf32>, f32
 
   %c2 = constant 2 : index
-  store %f4, %B[%c2, %c2, %c2]: memref<?x?x?xf32>
-  %U = memref_cast %B : memref<?x?x?xf32> to memref<*xf32>
+  memref.store %f4, %B[%c2, %c2, %c2]: memref<?x?x?xf32>
+  %U = memref.cast %B : memref<?x?x?xf32> to memref<*xf32>
   call @print_memref_f32(%U): (memref<*xf32>) -> ()
-  dealloc %A : memref<3x4x5xf32>
+  memref.dealloc %A : memref<3x4x5xf32>
   return
 }
 // PRINT-3D: Unranked Memref base@ = {{.*}} rank = 3 offset = 0 sizes = [3, 4, 5] strides = [20, 5, 1] data =
 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-2: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    4,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    2,    2,    2
 
 func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
 !vector_type_C = type vector<4x4xf32>
 !matrix_type_CC = type memref<1x1x!vector_type_C>
 func @vector_splat_2d() {
   %c0 = constant 0 : index
   %f10 = constant 10.0 : f32
   %vf10 = splat %f10: !vector_type_C
-  %C = alloc() : !matrix_type_CC
-  store %vf10, %C[%c0, %c0]: !matrix_type_CC
+  %C = memref.alloc() : !matrix_type_CC
+  memref.store %vf10, %C[%c0, %c0]: !matrix_type_CC
 
-  %CC = memref_cast %C: !matrix_type_CC to memref<?x?x!vector_type_C>
+  %CC = memref.cast %C: !matrix_type_CC to memref<?x?x!vector_type_C>
   call @print_memref_vector_4x4xf32(%CC): (memref<?x?x!vector_type_C>) -> ()
 
-  dealloc %C : !matrix_type_CC
+  memref.dealloc %C : !matrix_type_CC
   return
 }
 
 // PRINT-VECTOR-SPLAT-2D: Memref base@ = {{.*}} rank = 2 offset = 0 sizes = [1, 1] strides = [1, 1] data =
 // PRINT-VECTOR-SPLAT-2D-NEXT: [((10, 10, 10, 10),   (10, 10, 10, 10),   (10, 10, 10, 10),   (10, 10, 10, 10))]
 
 func private @print_memref_vector_4x4xf32(memref<?x?x!vector_type_C>) attributes { llvm.emit_c_interface }

mlir/test/mlir-opt/commandline.mlir

 // RUN: mlir-opt --show-dialects | FileCheck %s
 // CHECK: Available Dialects:
 // CHECK-NEXT: acc
 // CHECK-NEXT: affine
 // CHECK-NEXT: arm_neon
 // CHECK-NEXT: arm_sve
 // CHECK-NEXT: async
 // CHECK-NEXT: avx512
 // CHECK-NEXT: complex
 // CHECK-NEXT: gpu
 // CHECK-NEXT: linalg
 // CHECK-NEXT: llvm
 // CHECK-NEXT: llvm_arm_neon
 // CHECK-NEXT: llvm_arm_sve
 // CHECK-NEXT: llvm_avx512
 // CHECK-NEXT: math
+// CHECK-NEXT: memref
 // CHECK-NEXT: nvvm
 // CHECK-NEXT: omp
 // CHECK-NEXT: pdl
 // CHECK-NEXT: pdl_interp
 // CHECK-NEXT: quant
 // CHECK-NEXT: rocdl
 // CHECK-NEXT: scf
 // CHECK-NEXT: sdbm
 // CHECK-NEXT: shape
 // CHECK-NEXT: spv
 // CHECK-NEXT: std
 // CHECK-NEXT: tensor
 // CHECK-NEXT: test
 // CHECK-NEXT: tosa
 // CHECK-NEXT: vector

mlir/test/mlir-reduce/multiple-function.mlir

 // UNSUPPORTED: system-windows
 // RUN: mlir-reduce %s -test %S/failure-test.sh -pass-test function-reducer | FileCheck %s
-// This input should be reduced by the pass pipeline so that only 
-// the @simple5 function remains as this is the shortest function 
+// This input should be reduced by the pass pipeline so that only
+// the @simple5 function remains as this is the shortest function
 // containing the interesting behavior.
 
 // CHECK-NOT: func @simple1() {
 func @simple1() {
   return
 }
 
 // CHECK-NOT: func @simple2() {
 func @simple2() {
   return
 }
 
 // CHECK-LABEL: func @simple3() {
 func @simple3() {
   "test.crashOp" () : () -> ()
   return
 }
 
 // CHECK-NOT: func @simple4() {
 func @simple4(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   "test.crashOp"(%1, %arg2) : (memref<2xf32>, memref<2xf32>) -> ()
   return
 }
 
 // CHECK-NOT: func @simple5() {
 func @simple5() {
   return
 }

mlir/test/mlir-reduce/simple-test.mlir

 // UNSUPPORTED: system-windows
 // RUN: mlir-reduce %s -test %S/test.sh -pass-test function
 
 func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   cond_br %arg0, ^bb1, ^bb2
 ^bb1:
   br ^bb3(%arg1 : memref<2xf32>)
 ^bb2:
-  %0 = alloc() : memref<2xf32>
+  %0 = memref.alloc() : memref<2xf32>
   br ^bb3(%0 : memref<2xf32>)
 ^bb3(%1: memref<2xf32>):
   return
 }

mlir/unittests/ExecutionEngine/Invoke.cpp

 TEST(NativeMemRefJit, ZeroRankMemref) {
   OwningMemRef<float, 0> A({});
   A[{}] = 42.;
   ASSERT_EQ(*A->data, 42);
   A[{}] = 0;
   std::string moduleStr = R"mlir(
   func @zero_ranked(%arg0 : memref<f32>) attributes { llvm.emit_c_interface } {
     %cst42 = constant 42.0 : f32
-    store %cst42, %arg0[] : memref<f32>
+    memref.store %cst42, %arg0[] : memref<f32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   auto module = parseSourceString(moduleStr, &context);
for (float &elt : *A) {
     EXPECT_EQ(&elt, &(A[{count - 1}]));
     elt = count++;
   }
 
   std::string moduleStr = R"mlir(
   func @one_ranked(%arg0 : memref<?xf32>) attributes { llvm.emit_c_interface } {
     %cst42 = constant 42.0 : f32
     %cst5 = constant 5 : index
-    store %cst42, %arg0[%cst5] : memref<?xf32>
+    memref.store %cst42, %arg0[%cst5] : memref<?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   auto module = parseSourceString(moduleStr, &context);
for (int j = 0; j < M; ++j) {
       EXPECT_EQ(&(A[{i, j}]), &((*A)[i][j]));
     }
   }
   std::string moduleStr = R"mlir(
   func @rank2_memref(%arg0 : memref<?x?xf32>, %arg1 : memref<?x?xf32>) attributes { llvm.emit_c_interface } {
     %x = constant 2 : index
     %y = constant 1 : index
     %cst42 = constant 42.0 : f32
-    store %cst42, %arg0[%y, %x] : memref<?x?xf32>
-    store %cst42, %arg1[%x, %y] : memref<?x?xf32>
+    memref.store %cst42, %arg0[%y, %x] : memref<?x?xf32>
+    memref.store %cst42, %arg1[%x, %y] : memref<?x?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   OwningModuleRef module = parseSourceString(moduleStr, &context);
TEST(NativeMemRefJit, JITCallback) {
   int64_t shape[] = {K, M};
   int64_t shapeAlloc[] = {K + 1, M + 1};
   OwningMemRef<float, 2> A(shape, shapeAlloc);
   int count = 1;
   for (float &elt : *A)
     elt = count++;
 
   std::string moduleStr = R"mlir(
-  func private @callback(%arg0: memref<?x?xf32>, %coefficient: i32)  attributes { llvm.emit_c_interface } 
+  func private @callback(%arg0: memref<?x?xf32>, %coefficient: i32)  attributes { llvm.emit_c_interface }
   func @caller_for_callback(%arg0: memref<?x?xf32>, %coefficient: i32) attributes { llvm.emit_c_interface } {
-    %unranked = memref_cast %arg0: memref<?x?xf32> to memref<*xf32>
+    %unranked = memref.cast %arg0: memref<?x?xf32> to memref<*xf32>
     call @callback(%arg0, %coefficient) : (memref<?x?xf32>, i32) -> ()
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);