Add a lowering for memref.dealloc with unranked memrefs.

[jreiffers]

Summary

This is permitted by the op, but the current lowering generates invalid IR.

[springerm]

The way I interpret the memref::DeallocOp documentation, deallocating an unranked memref is currently considered invalid IR.

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).

All allocs originate from a memref.alloc. They must have been casted to an unranked memref. It would be invalid to dealloc this alias.

I'm not sure why we have this restriction on memref.dealloc, but I think it is because it makes buffer deallocation simpler. But it would also disallow deallocating a memref returned from an scf.if/scf.for, which is probably not what we want. We should probably update the documentation. Any thoughts?

[jreiffers]

I guess the definition is not entirely consistent right now. This lowering works (and I need it for experimental deallocation), so let's update the docs. We can either just remove that sentence (after double checking that the allocated pointer is always preserved) or change it to something more accurate. I'll check and then update this.

[jreiffers]

Update docs.

[jreiffers]

For now I removed the note. If anyone would prefer a positive note (e.g. "Calling dealloc on the results of cast operations is valid") let me know.

[springerm]

on second thought, we should probably keep the comment because now it makes the impression that the buffer deallocation pass works with memref.subview when it does not (I think). You're just adding the llvm lowering here so that does not contradict the comment yet.

[jreiffers]

Revert docs change.

[jreiffers]

In D144090#4128965, @springerm wrote:

on second thought, we should probably keep the comment because now it makes the impression that the buffer deallocation pass works with memref.subview when it does not (I think). You're just adding the llvm lowering here so that does not contradict the comment yet.

Works for me. Thanks!

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

explicit DeallocOpLowering(LLVMTypeConverter &converter)
       : ConvertOpToLLVMPattern<memref::DeallocOp>(converter) {}
 
   LogicalResult
   matchAndRewrite(memref::DeallocOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Insert the `free` declaration if it is not already present.
     LLVM::LLVMFuncOp freeFunc =
         getFreeFn(getTypeConverter(), op->getParentOfType<ModuleOp>());
-    MemRefDescriptor memref(adaptor.getMemref());
-    Value allocatedPtr = memref.allocatedPtr(rewriter, op.getLoc());
-    Value casted = allocatedPtr;
+    Value allocatedPtr;
+    if (auto unrankedTy =
+            llvm::dyn_cast<UnrankedMemRefType>(op.getMemref().getType())) {
+      Type elementType = unrankedTy.getElementType();
+      Type llvmElementTy = getTypeConverter()->convertType(elementType);
+      LLVM::LLVMPointerType elementPtrTy = getTypeConverter()->getPointerType(
+          llvmElementTy, unrankedTy.getMemorySpaceAsInt());
+      allocatedPtr = UnrankedMemRefDescriptor::allocatedPtr(
+          rewriter, op.getLoc(),
+          UnrankedMemRefDescriptor(adaptor.getMemref())
+              .memRefDescPtr(rewriter, op.getLoc()),
+          elementPtrTy);
+    } else {
+      allocatedPtr = MemRefDescriptor(adaptor.getMemref())
+                         .allocatedPtr(rewriter, op.getLoc());
+    }
     if (!getTypeConverter()->useOpaquePointers())
-      casted = rewriter.create<LLVM::BitcastOp>(op.getLoc(), getVoidPtrType(),
-                                                allocatedPtr);
+      allocatedPtr = rewriter.create<LLVM::BitcastOp>(
+          op.getLoc(), getVoidPtrType(), allocatedPtr);
 
-    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, freeFunc, casted);
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, freeFunc, allocatedPtr);
     return success();
   }
 };
 
 // A `dim` is converted to a constant for static sizes and to an access to the
 // size stored in the memref descriptor for dynamic sizes.
 struct DimOpLowering : public ConvertOpToLLVMPattern<memref::DimOp> {
   using ConvertOpToLLVMPattern<memref::DimOp>::ConvertOpToLLVMPattern;

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

 //      CHECK:  %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)>
 // CHECK-NEXT:  llvm.call @free(%[[ptr]]) : (!llvm.ptr) -> ()
   memref.dealloc %arg0 : memref<?x42x?xf32>
   return
 }
 
 // -----
 
+// CHECK-LABEL: func @unranked_dealloc
+func.func @unranked_dealloc(%arg0: memref<*xf32>) {
+//      CHECK: %[[memref:.*]] = llvm.extractvalue %{{.*}} : !llvm.struct<(i64, ptr)>
+//      CHECK: %[[ptr:.*]] = llvm.load %[[memref]]
+// CHECK-NEXT: llvm.call @free(%[[ptr]])
+  memref.dealloc %arg0 : memref<*xf32>
+  return
+}
+
+// -----
+
 // CHECK-LABEL: func @dynamic_alloc(
 //       CHECK:   %[[Marg:.*]]: index, %[[Narg:.*]]: index)
 func.func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
 //   CHECK-DAG:  %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
 //   CHECK-DAG:  %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
 //  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