[Mlir-commits] [mlir] [mlir][ptr] Add load/store lowring to LLVM (PR #173405)

[Ivan Butygin]

https://github.com/Hardcode84 created https://github.com/llvm/llvm-project/pull/173405

None

>From 08b19c70c60772edf35e9b16e7a377231733fc07 Mon Sep 17 00:00:00 2001
From: Ivan Butygin <ivan.butygin at gmail.com>
Date: Tue, 23 Dec 2025 19:19:04 +0100
Subject: [PATCH] [mlir][ptr] Add load/store lowring to LLVM

---
 mlir/lib/Conversion/PtrToLLVM/PtrToLLVM.cpp   | 56 ++++++++++++++++++-
 .../Conversion/PtrToLLVM/ptr-to-llvm.mlir     | 38 +++++++++++++
 2 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/mlir/lib/Conversion/PtrToLLVM/PtrToLLVM.cpp b/mlir/lib/Conversion/PtrToLLVM/PtrToLLVM.cpp
index 86106b27a2bd4..b0e8129fb8f6b 100644
--- a/mlir/lib/Conversion/PtrToLLVM/PtrToLLVM.cpp
+++ b/mlir/lib/Conversion/PtrToLLVM/PtrToLLVM.cpp
@@ -370,6 +370,59 @@ LogicalResult TypeOffsetOpConversion::matchAndRewrite(
   return success();
 }
 
+static LLVM::AtomicOrdering getLLVMAtomicOrdering(ptr::AtomicOrdering order) {
+  switch (order) {
+  case ptr::AtomicOrdering::not_atomic:
+    return LLVM::AtomicOrdering::not_atomic;
+  case ptr::AtomicOrdering::monotonic:
+    return LLVM::AtomicOrdering::monotonic;
+  case ptr::AtomicOrdering::acquire:
+    return LLVM::AtomicOrdering::acquire;
+  case ptr::AtomicOrdering::release:
+    return LLVM::AtomicOrdering::release;
+  case ptr::AtomicOrdering::acq_rel:
+    return LLVM::AtomicOrdering::acq_rel;
+  case ptr::AtomicOrdering::seq_cst:
+    return LLVM::AtomicOrdering::seq_cst;
+  case ptr::AtomicOrdering::unordered:
+    return LLVM::AtomicOrdering::unordered;
+  }
+  llvm_unreachable("Unknown atomic ordering");
+}
+
+struct PtrLoadOpConversion : public ConvertOpToLLVMPattern<ptr::LoadOp> {
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
+  LogicalResult
+  matchAndRewrite(ptr::LoadOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    Type resultType = typeConverter->convertType(op.getType());
+    if (!resultType)
+      return rewriter.notifyMatchFailure(op,
+                                         "Couldn't convert the result type");
+
+    rewriter.replaceOpWithNewOp<LLVM::LoadOp>(
+        op, resultType, adaptor.getPtr(), op.getAlignment().value_or(0),
+        op.getVolatile_(), op.getNontemporal(), op.getInvariant(),
+        op.getInvariantGroup(), getLLVMAtomicOrdering(op.getOrdering()),
+        op.getSyncscope().value_or(StringRef()));
+    return success();
+  }
+};
+
+struct PtrStoreOpConversion : public ConvertOpToLLVMPattern<ptr::StoreOp> {
+  using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
+  LogicalResult
+  matchAndRewrite(ptr::StoreOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<LLVM::StoreOp>(
+        op, adaptor.getValue(), adaptor.getPtr(), op.getAlignment().value_or(0),
+        op.getVolatile_(), op.getNontemporal(), op.getInvariantGroup(),
+        getLLVMAtomicOrdering(op.getOrdering()),
+        op.getSyncscope().value_or(StringRef()));
+    return success();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // ConvertToLLVMPatternInterface implementation
 //===----------------------------------------------------------------------===//
@@ -431,7 +484,8 @@ void mlir::ptr::populatePtrToLLVMConversionPatterns(
 
   // Add conversion patterns.
   patterns.add<FromPtrOpConversion, GetMetadataOpConversion, PtrAddOpConversion,
-               ToPtrOpConversion, TypeOffsetOpConversion>(converter);
+               ToPtrOpConversion, TypeOffsetOpConversion, PtrLoadOpConversion,
+               PtrStoreOpConversion>(converter);
 }
 
 void mlir::ptr::registerConvertPtrToLLVMInterface(DialectRegistry &registry) {
diff --git a/mlir/test/Conversion/PtrToLLVM/ptr-to-llvm.mlir b/mlir/test/Conversion/PtrToLLVM/ptr-to-llvm.mlir
index 5128fd8ccb265..387eabc29b3f2 100644
--- a/mlir/test/Conversion/PtrToLLVM/ptr-to-llvm.mlir
+++ b/mlir/test/Conversion/PtrToLLVM/ptr-to-llvm.mlir
@@ -316,3 +316,41 @@ func.func @test_memref_ptradd_indexing(%arg0: memref<10x?x30xf32, #ptr.generic_s
   %3 = ptr.ptr_add %0, %2 : !ptr.ptr<#ptr.generic_space>, index
   return %3 : !ptr.ptr<#ptr.generic_space>
 }
+
+// CHECK-LABEL:  func @test_load_ops
+//  CHECK-SAME:    (%[[ARG:.*]]: !llvm.ptr)
+//       CHECK:    %{{.*}} = llvm.load %[[ARG]] : !llvm.ptr -> f32
+//       CHECK:    %{{.*}} = llvm.load volatile %[[ARG]] : !llvm.ptr -> f32
+//       CHECK:    %{{.*}} = llvm.load %[[ARG]] {nontemporal} : !llvm.ptr -> f32
+//       CHECK:    %{{.*}} = llvm.load %[[ARG]] invariant : !llvm.ptr -> f32
+//       CHECK:    %{{.*}} = llvm.load %[[ARG]] invariant_group : !llvm.ptr -> f32
+//       CHECK:    %{{.*}} = llvm.load %[[ARG]] atomic monotonic {alignment = 8 : i64} : !llvm.ptr -> i64
+//       CHECK:    %{{.*}} = llvm.load volatile %[[ARG]] atomic syncscope("workgroup") acquire {alignment = 4 : i64, nontemporal} : !llvm.ptr -> i32
+func.func @test_load_ops(%arg0: !ptr.ptr<#ptr.generic_space>) -> (f32, f32, f32, f32, f32, i64, i32) {
+  %0 = ptr.load %arg0 : !ptr.ptr<#ptr.generic_space> -> f32
+  %1 = ptr.load volatile %arg0 : !ptr.ptr<#ptr.generic_space> -> f32
+  %2 = ptr.load %arg0 nontemporal : !ptr.ptr<#ptr.generic_space> -> f32
+  %3 = ptr.load %arg0 invariant : !ptr.ptr<#ptr.generic_space> -> f32
+  %4 = ptr.load %arg0 invariant_group : !ptr.ptr<#ptr.generic_space> -> f32
+  %5 = ptr.load %arg0 atomic monotonic alignment = 8 : !ptr.ptr<#ptr.generic_space> -> i64
+  %6 = ptr.load volatile %arg0 atomic syncscope("workgroup") acquire nontemporal alignment = 4 : !ptr.ptr<#ptr.generic_space> -> i32
+  return %0, %1, %2, %3, %4, %5, %6 : f32, f32, f32, f32, f32, i64, i32
+}
+
+// CHECK-LABEL:  func @test_store_ops
+//  CHECK-SAME:    (%[[ARG0:.*]]: !llvm.ptr, %[[ARG1:.*]]: f32, %[[ARG2:.*]]: i64, %[[ARG3:.*]]: i32)
+//       CHECK:    llvm.store %[[ARG1]], %[[ARG0]] : f32, !llvm.ptr
+//       CHECK:    llvm.store volatile %[[ARG1]], %[[ARG0]] : f32, !llvm.ptr
+//       CHECK:    llvm.store %[[ARG1]], %[[ARG0]] {nontemporal} : f32, !llvm.ptr
+//       CHECK:    llvm.store %[[ARG1]], %[[ARG0]] invariant_group : f32, !llvm.ptr
+//       CHECK:    llvm.store %[[ARG2]], %[[ARG0]] atomic monotonic {alignment = 8 : i64} : i64, !llvm.ptr
+//       CHECK:    llvm.store volatile %[[ARG3]], %[[ARG0]] atomic syncscope("workgroup") release {alignment = 4 : i64, nontemporal} : i32, !llvm.ptr
+func.func @test_store_ops(%arg0: !ptr.ptr<#ptr.generic_space>, %arg1: f32, %arg2: i64, %arg3: i32) {
+  ptr.store %arg1, %arg0 : f32, !ptr.ptr<#ptr.generic_space>
+  ptr.store volatile %arg1, %arg0 : f32, !ptr.ptr<#ptr.generic_space>
+  ptr.store %arg1, %arg0 nontemporal : f32, !ptr.ptr<#ptr.generic_space>
+  ptr.store %arg1, %arg0 invariant_group : f32, !ptr.ptr<#ptr.generic_space>
+  ptr.store %arg2, %arg0 atomic monotonic alignment = 8 : i64, !ptr.ptr<#ptr.generic_space>
+  ptr.store volatile %arg3, %arg0 atomic syncscope("workgroup") release nontemporal alignment = 4 : i32, !ptr.ptr<#ptr.generic_space>
+  return
+}