[mlir] fix shared-lib build fallout of e231070

The patch in question broke the build with shared libraries due to
missing dependencies, one of which would have been circular between
MLIRStandard and MLIRMemRef if added. Fix this by moving more code
around and swapping the dependency direction. MLIRMemRef now depends on
MLIRStandard, but MLIRStandard does _not_ depend on MLIRMemRef.
Arguably, this is the right direction anyway since numerous libraries
depend on MLIRStandard and don't necessarily need to depend on
MLIRMemref.

Other otable changes include:
- some EDSC code is moved inline to MemRef/EDSC/Intrinsics.h because it
  creates MemRef dialect operations;
- a utility function related to shape moved to BuiltinTypes.h/cpp
  because it only realtes to shaped types and not any particular dialect
  (standard dialect is erroneously believed to contain MemRefType);
- a Python test for the standard dialect is disabled completely because
  the ops it tests moved to the new MemRef dialect, but it is not
  exposed to Python bindings, and the change for that is non-trivial.

Author: ftynse

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

@@ -9,8 +9,12 @@
 #define MLIR_DIALECT_MEMREF_EDSC_INTRINSICS_H_
 
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/StandardOps/EDSC/Builders.h"
+#include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/EDSC/Builders.h"
 
+#include "llvm/ADT/SmallVector.h"
+
 namespace mlir {
 namespace edsc {
 namespace intrinsics {
@@ -34,4 +38,52 @@ using MemRefIndexedValue =
 } // namespace edsc
 } // namespace mlir
 
+static inline ::llvm::SmallVector<mlir::Value, 8>
+getMemRefSizes(mlir::Value memRef) {
+  using namespace mlir;
+  using namespace mlir::edsc;
+  using namespace mlir::edsc::intrinsics;
+  mlir::MemRefType memRefType = memRef.getType().cast<mlir::MemRefType>();
+  assert(isStrided(memRefType) && "Expected strided MemRef type");
+
+  SmallVector<mlir::Value, 8> res;
+  res.reserve(memRefType.getShape().size());
+  const auto &shape = memRefType.getShape();
+  for (unsigned idx = 0, n = shape.size(); idx < n; ++idx) {
+    if (shape[idx] == -1)
+      res.push_back(memref_dim(memRef, idx));
+    else
+      res.push_back(std_constant_index(shape[idx]));
+  }
+  return res;
+}
+
+namespace mlir {
+namespace edsc {
+
+/// A MemRefBoundsCapture represents the information required to step through a
+/// MemRef. It has placeholders for non-contiguous tensors that fit within the
+/// Fortran subarray model.
+/// At the moment it can only capture a MemRef with an identity layout map.
+// TODO: Support MemRefs with layoutMaps.
+class MemRefBoundsCapture : public BoundsCapture {
+public:
+  explicit MemRefBoundsCapture(Value v) {
+    auto memrefSizeValues = getMemRefSizes(v);
+    for (auto s : memrefSizeValues) {
+      lbs.push_back(intrinsics::std_constant_index(0));
+      ubs.push_back(s);
+      steps.push_back(1);
+    }
+  }
+
+  unsigned fastestVarying() const { return rank() - 1; }
+
+private:
+  Value base;
+};
+
+} // namespace edsc
+} // namespace mlir
+
 #endif // MLIR_DIALECT_MEMREF_EDSC_INTRINSICS_H_

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

@@ -16,13 +16,21 @@
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 namespace mlir {
+
+class Location;
+class OpBuilder;
+
 raw_ostream &operator<<(raw_ostream &os, Range &range);
 
 /// Return the list of Range (i.e. offset, size, stride). Each Range
 /// entry contains either the dynamic value or a ConstantIndexOp constructed
 /// with `b` at location `loc`.
 SmallVector<Range, 8> getOrCreateRanges(OffsetSizeAndStrideOpInterface op,
                                         OpBuilder &b, Location loc);
+
+/// Given an operation, retrieves the value of each dynamic dimension through
+/// constructing the necessary DimOp operators.
+SmallVector<Value, 4> getDynOperands(Location loc, Value val, OpBuilder &b);
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//

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

@@ -44,21 +44,6 @@ class BoundsCapture {
   SmallVector<int64_t, 8> steps;
 };
 
-/// A MemRefBoundsCapture represents the information required to step through a
-/// MemRef. It has placeholders for non-contiguous tensors that fit within the
-/// Fortran subarray model.
-/// At the moment it can only capture a MemRef with an identity layout map.
-// TODO: Support MemRefs with layoutMaps.
-class MemRefBoundsCapture : public BoundsCapture {
-public:
-  explicit MemRefBoundsCapture(Value v);
-
-  unsigned fastestVarying() const { return rank() - 1; }
-
-private:
-  Value base;
-};
-
 /// A VectorBoundsCapture represents the information required to step through a
 /// Vector accessing each scalar element at a time. It is the counterpart of
 /// a MemRefBoundsCapture but for vectors. This exists purely for boilerplate

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

@@ -108,18 +108,6 @@ class ConstantIndexOp : public ConstantOp {
   static bool classof(Operation *op);
 };
 
-/// Given an `originalShape` and a `reducedShape` assumed to be a subset of
-/// `originalShape` with some `1` entries erased, return the set of indices
-/// that specifies which of the entries of `originalShape` are dropped to obtain
-/// `reducedShape`. The returned mask can be applied as a projection to
-/// `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);
-
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 /// comparison predicates.
 bool applyCmpPredicate(CmpIPredicate predicate, const APInt &lhs,

mlir/include/mlir/Dialect/StandardOps/Utils/Utils.h

@@ -23,13 +23,6 @@
 
 namespace mlir {
 
-class Location;
-class OpBuilder;
-
-/// Given an operation, retrieves the value of each dynamic dimension through
-/// constructing the necessary DimOp operators.
-SmallVector<Value, 4> getDynOperands(Location loc, Value val, OpBuilder &b);
-
 /// Matches a ConstantIndexOp.
 detail::op_matcher<ConstantIndexOp> matchConstantIndex();
 

mlir/include/mlir/IR/BuiltinTypes.h

@@ -245,6 +245,18 @@ class MemRefType::Builder {
   Attribute memorySpace;
 };
 
+/// Given an `originalShape` and a `reducedShape` assumed to be a subset of
+/// `originalShape` with some `1` entries erased, return the set of indices
+/// that specifies which of the entries of `originalShape` are dropped to obtain
+/// `reducedShape`. The returned mask can be applied as a projection to
+/// `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);
+
 //===----------------------------------------------------------------------===//
 // Deferred Method Definitions
 //===----------------------------------------------------------------------===//

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

@@ -6,6 +6,7 @@ add_mlir_dialect_library(MLIRMemRef
   ${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRefDialect
 
   DEPENDS
+  MLIRStandardOpsIncGen
   MLIRMemRefOpsIncGen
 
   LINK_COMPONENTS
@@ -14,4 +15,7 @@ add_mlir_dialect_library(MLIRMemRef
   LINK_LIBS PUBLIC
   MLIRDialect
   MLIRIR
+  MLIRStandard
+  MLIRTensor
+  MLIRViewLikeInterface
 )

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

@@ -30,6 +30,17 @@ struct MemRefInlinerInterface : public DialectInlinerInterface {
 };
 } // end anonymous namespace
 
+SmallVector<Value, 4> mlir::getDynOperands(Location loc, Value val,
+                                           OpBuilder &b) {
+  SmallVector<Value, 4> dynOperands;
+  auto shapedType = val.getType().cast<ShapedType>();
+  for (auto dim : llvm::enumerate(shapedType.getShape())) {
+    if (dim.value() == MemRefType::kDynamicSize)
+      dynOperands.push_back(b.create<memref::DimOp>(loc, val, dim.index()));
+  }
+  return dynOperands;
+}
+
 void mlir::memref::MemRefDialect::initialize() {
   addOperations<DmaStartOp, DmaWaitOp,
 #define GET_OP_LIST

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

@@ -1560,40 +1560,6 @@ void SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
 /// For ViewLikeOpInterface.
 Value SubViewOp::getViewSource() { return source(); }
 
-/// Given an `originalShape` and a `reducedShape` assumed to be a subset of
-/// `originalShape` with some `1` entries erased, return the set of indices
-/// that specifies which of the entries of `originalShape` are dropped to obtain
-/// `reducedShape`. The returned mask can be applied as a projection to
-/// `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>>
-mlir::computeRankReductionMask(ArrayRef<int64_t> originalShape,
-                               ArrayRef<int64_t> reducedShape) {
-  size_t originalRank = originalShape.size(), reducedRank = reducedShape.size();
-  llvm::SmallDenseSet<unsigned> unusedDims;
-  unsigned reducedIdx = 0;
-  for (unsigned originalIdx = 0; originalIdx < originalRank; ++originalIdx) {
-    // Greedily insert `originalIdx` if no match.
-    if (reducedIdx < reducedRank &&
-        originalShape[originalIdx] == reducedShape[reducedIdx]) {
-      reducedIdx++;
-      continue;
-    }
-
-    unusedDims.insert(originalIdx);
-    // If no match on `originalIdx`, the `originalShape` at this dimension
-    // must be 1, otherwise we bail.
-    if (originalShape[originalIdx] != 1)
-      return llvm::None;
-  }
-  // The whole reducedShape must be scanned, otherwise we bail.
-  if (reducedIdx != reducedRank)
-    return llvm::None;
-  return unusedDims;
-}
-
 enum SubViewVerificationResult {
   Success,
   RankTooLarge,

mlir/lib/Dialect/StandardOps/CMakeLists.txt

@@ -16,7 +16,6 @@ add_mlir_dialect_library(MLIRStandard
   MLIRControlFlowInterfaces
   MLIREDSC
   MLIRIR
-  MLIRMemRef
   MLIRSideEffectInterfaces
   MLIRTensor
   MLIRVectorInterfaces

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

@@ -6,7 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/MemRef/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
@@ -15,31 +14,6 @@ using namespace mlir;
 using namespace mlir::edsc;
 using namespace mlir::edsc::intrinsics;
 
-static SmallVector<Value, 8> getMemRefSizes(Value memRef) {
-  MemRefType memRefType = memRef.getType().cast<MemRefType>();
-  assert(isStrided(memRefType) && "Expected strided MemRef type");
-
-  SmallVector<Value, 8> res;
-  res.reserve(memRefType.getShape().size());
-  const auto &shape = memRefType.getShape();
-  for (unsigned idx = 0, n = shape.size(); idx < n; ++idx) {
-    if (shape[idx] == -1)
-      res.push_back(memref_dim(memRef, idx));
-    else
-      res.push_back(std_constant_index(shape[idx]));
-  }
-  return res;
-}
-
-mlir::edsc::MemRefBoundsCapture::MemRefBoundsCapture(Value v) {
-  auto memrefSizeValues = getMemRefSizes(v);
-  for (auto s : memrefSizeValues) {
-    lbs.push_back(std_constant_index(0));
-    ubs.push_back(s);
-    steps.push_back(1);
-  }
-}
-
 mlir::edsc::VectorBoundsCapture::VectorBoundsCapture(VectorType t) {
   for (auto s : t.getShape()) {
     lbs.push_back(std_constant_index(0));

mlir/lib/Dialect/StandardOps/Utils/Utils.cpp

@@ -12,22 +12,10 @@
 
 #include "mlir/Dialect/StandardOps/Utils/Utils.h"
 
-#include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 
 using namespace mlir;
 
-SmallVector<Value, 4> mlir::getDynOperands(Location loc, Value val,
-                                           OpBuilder &b) {
-  SmallVector<Value, 4> dynOperands;
-  auto shapedType = val.getType().cast<ShapedType>();
-  for (auto dim : llvm::enumerate(shapedType.getShape())) {
-    if (dim.value() == MemRefType::kDynamicSize)
-      dynOperands.push_back(b.create<memref::DimOp>(loc, val, dim.index()));
-  }
-  return dynOperands;
-}
-
 /// Matches a ConstantIndexOp.
 /// TODO: This should probably just be a general matcher that uses matchConstant
 /// and checks the operation for an index type.

mlir/lib/IR/BuiltinTypes.cpp

@@ -465,6 +465,40 @@ unsigned BaseMemRefType::getMemorySpaceAsInt() const {
 // MemRefType
 //===----------------------------------------------------------------------===//
 
+/// Given an `originalShape` and a `reducedShape` assumed to be a subset of
+/// `originalShape` with some `1` entries erased, return the set of indices
+/// that specifies which of the entries of `originalShape` are dropped to obtain
+/// `reducedShape`. The returned mask can be applied as a projection to
+/// `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>>
+mlir::computeRankReductionMask(ArrayRef<int64_t> originalShape,
+                               ArrayRef<int64_t> reducedShape) {
+  size_t originalRank = originalShape.size(), reducedRank = reducedShape.size();
+  llvm::SmallDenseSet<unsigned> unusedDims;
+  unsigned reducedIdx = 0;
+  for (unsigned originalIdx = 0; originalIdx < originalRank; ++originalIdx) {
+    // Greedily insert `originalIdx` if no match.
+    if (reducedIdx < reducedRank &&
+        originalShape[originalIdx] == reducedShape[reducedIdx]) {
+      reducedIdx++;
+      continue;
+    }
+
+    unusedDims.insert(originalIdx);
+    // If no match on `originalIdx`, the `originalShape` at this dimension
+    // must be 1, otherwise we bail.
+    if (originalShape[originalIdx] != 1)
+      return llvm::None;
+  }
+  // The whole reducedShape must be scanned, otherwise we bail.
+  if (reducedIdx != reducedRank)
+    return llvm::None;
+  return unusedDims;
+}
+
 bool mlir::detail::isSupportedMemorySpace(Attribute memorySpace) {
   // Empty attribute is allowed as default memory space.
   if (!memorySpace)