[mlir][MemRef] Return `0` for the canonical strided layout expr of a 0d memref

[bkramer]

Summary

There can't be any strides, and the offset for the canonical expr is
always 0. Fixes #55229.

mlir/lib/IR/BuiltinTypes.cpp

if (expr != simplifiedLayoutExpr)
     return MemRefType::Builder(t).setLayout(AffineMapAttr::get(AffineMap::get(
         m.getNumDims(), m.getNumSymbols(), simplifiedLayoutExpr)));
   return MemRefType::Builder(t).setLayout({});
 }
 
 AffineExpr mlir::makeCanonicalStridedLayoutExpr(ArrayRef<int64_t> sizes,
                                                 ArrayRef<AffineExpr> exprs,
                                                 MLIRContext *context) {
-  assert(!sizes.empty() && !exprs.empty() &&
-         "expected non-empty sizes and exprs");
-
   // Size 0 corner case is useful for canonicalizations.
-  if (llvm::is_contained(sizes, 0))
+  if (sizes.empty() || llvm::is_contained(sizes, 0))
     return getAffineConstantExpr(0, context);
 
+  assert(!exprs.empty() && "expected exprs");
   auto maps = AffineMap::inferFromExprList(exprs);
   assert(!maps.empty() && "Expected one non-empty map");
   unsigned numDims = maps[0].getNumDims(), nSymbols = maps[0].getNumSymbols();
 
   AffineExpr expr;
   bool dynamicPoisonBit = false;
   int64_t runningSize = 1;
   for (auto en : llvm::zip(llvm::reverse(exprs), llvm::reverse(sizes))) {

mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir

func.func @memref_copy_contiguous(%in: memref<16x2xi32>, %offset: index) {
   // CHECK: [[GEP2:%.*]] = llvm.getelementptr [[EXTRACT2P]][[[EXTRACT2O]]] : (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
   // CHECK: [[VOLATILE:%.*]] = llvm.mlir.constant(false) : i1
   // CHECK: "llvm.intr.memcpy"([[GEP2]], [[GEP1]], [[SIZE]], [[VOLATILE]]) : (!llvm.ptr<i32>, !llvm.ptr<i32>, i64, i1) -> ()
   return
 }
 
 // -----
 
+// CHECK-LABEL: func @memref_copy_0d_offset
+#map0 = affine_map<(d0) -> (d0 + 1)>
+#map1 = affine_map<() -> (1)>
+func.func @memref_copy_0d_offset(%in: memref<2xi32>) {
+  %buf = memref.alloc() : memref<i32>
+  %sub = memref.subview %in[1] [1] [1] : memref<2xi32> to memref<1xi32, #map0>
+  %scalar = memref.collapse_shape %sub [] : memref<1xi32, #map0> into memref<i32, #map1>
+  memref.copy %scalar, %buf : memref<i32, #map1> to memref<i32>
+  // CHECK: llvm.intr.memcpy
+  return
+}
+
+// -----
+
 // CHECK-LABEL: func @memref_copy_noncontiguous
 #map = affine_map<(d0, d1)[s0] -> (d0 * 2 + s0 + d1)>
 func.func @memref_copy_noncontiguous(%in: memref<16x2xi32>, %offset: index) {
   %buf = memref.alloc() : memref<2x1xi32>
   %sub = memref.subview %in[%offset, 0] [2, 1] [1, 1] : memref<16x2xi32> to memref<2x1xi32, #map>
   memref.copy %sub, %buf : memref<2x1xi32, #map> to memref<2x1xi32>
   // CHECK: llvm.call @memrefCopy
   return