//===- IndependenceTransforms.cpp - Make ops independent of values --------===// // // 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/Transforms/Transforms.h" #include "mlir/Dialect/Affine/IR/AffineOps.h" #include "mlir/Dialect/Affine/Transforms/Transforms.h" #include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/Utils/StaticValueUtils.h" #include "mlir/Interfaces/ValueBoundsOpInterface.h" usingnamespacemlir; usingnamespacemlir::memref; /// Make the given OpFoldResult independent of all independencies. static FailureOr<OpFoldResult> makeIndependent(OpBuilder &b, Location loc, OpFoldResult ofr, ValueRange independencies) { … } FailureOr<Value> memref::buildIndependentOp(OpBuilder &b, memref::AllocaOp allocaOp, ValueRange independencies) { … } /// Push down an UnrealizedConversionCastOp past a SubViewOp. static UnrealizedConversionCastOp propagateSubViewOp(RewriterBase &rewriter, UnrealizedConversionCastOp conversionOp, SubViewOp op) { … } /// Given an original op and a new, modified op with the same number of results, /// whose memref return types may differ, replace all uses of the original op /// with the new op and propagate the new memref types through the IR. /// /// Example: /// %from = memref.alloca(%sz) : memref<?xf32> /// %to = memref.subview ... : ... to memref<?xf32, strided<[1], offset: ?>> /// memref.store %cst, %from[%c0] : memref<?xf32> /// /// In the above example, all uses of %from are replaced with %to. This can be /// done directly for ops such as memref.store. For ops that have memref results /// (e.g., memref.subview), the result type may depend on the operand type, so /// we cannot just replace all uses. There is special handling for common memref /// ops. For all other ops, unrealized_conversion_cast is inserted. static void replaceAndPropagateMemRefType(RewriterBase &rewriter, Operation *from, Operation *to) { … } FailureOr<Value> memref::replaceWithIndependentOp(RewriterBase &rewriter, memref::AllocaOp allocaOp, ValueRange independencies) { … } memref::AllocaOp memref::allocToAlloca( RewriterBase &rewriter, memref::AllocOp alloc, function_ref<bool(memref::AllocOp, memref::DeallocOp)> filter) { … }