[mlir][CPURunner] Avoid a crash in memrefCopy when called with empty shapes.

[akuegel]

Summary

memrefCopy should just return early if there are no elements to copy.

mlir/lib/ExecutionEngine/CRunnerUtils.cpp

 
 extern "C" MLIR_CRUNNERUTILS_EXPORT void
 memrefCopy(int64_t elemSize, UnrankedMemRefType<char> *srcArg,
            UnrankedMemRefType<char> *dstArg) {
   DynamicMemRefType<char> src(*srcArg);
   DynamicMemRefType<char> dst(*dstArg);
 
   int64_t rank = src.rank;
+  // Handle empty shapes -> nothing to copy.
+  for (int rankp = 0; rankp < rank; ++rankp)
+    if (src.sizes[rankp] == 0)
+      return;
+
   char *srcPtr = src.data + src.offset * elemSize;
   char *dstPtr = dst.data + dst.offset * elemSize;
 
   if (rank == 0) {
     memcpy(dstPtr, srcPtr, elemSize);
     return;
   }
 
for (int64_t axis = rank - 1; axis >= 0; --axis) {
       writeIndex += dstStrides[axis];
       // If this is a valid index, we have our next index, so continue copying.
       if (src.sizes[axis] != newIndex)
         break;
       // We reached the end of this axis. If this is axis 0, we are done.
       if (axis == 0)
         return;
       // Else, reset to 0 and undo the advancement of the linear index that
-      // this axis had. The continue with the axis one outer.
+      // this axis had. Then continue with the axis one outer.
       indices[axis] = 0;
       readIndex -= src.sizes[axis] * srcStrides[axis];
       writeIndex -= dst.sizes[axis] * dstStrides[axis];
     }
   }
 }
 
 /// Prints GFLOPS rating.

mlir/test/mlir-cpu-runner/copy.mlir

func @main() -> () {
   memref.copy %input, %copy_two_casted : memref<2x3xf32> to memref<2x3xf32>
   %unranked_copy_two = memref.cast %copy_two : memref<3x2xf32> to memref<*xf32>
   call @print_memref_f32(%unranked_copy_two) : (memref<*xf32>) -> ()
   // CHECK: rank = 2 offset = 0 sizes = [3, 2] strides = [2, 1]
   // CHECK-NEXT: [0,   3]
   // CHECK-NEXT: [1,   4]
   // CHECK-NEXT: [2,   5]
 
+  %input_empty = memref.alloc() : memref<3x0x1xf32>
+  %copy_empty = memref.alloc() : memref<3x0x1xf32>
+  // Copying an empty shape should do nothing (and should not crash).
+  memref.copy %input_empty, %copy_empty : memref<3x0x1xf32> to memref<3x0x1xf32>
+
   return
 }