[CIR] Add default alignment to createStore

Author: FantasqueX

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -351,12 +351,14 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
 
   cir::StoreOp createStore(mlir::Location loc, mlir::Value val, mlir::Value dst,
                            bool _volatile = false,
-                           ::mlir::IntegerAttr align = {},
+                           uint64_t alignment = {},
                            cir::MemOrderAttr order = {}) {
     if (mlir::cast<cir::PointerType>(dst.getType()).getPointee() !=
         val.getType())
       dst = createPtrBitcast(dst, val.getType());
-    return create<cir::StoreOp>(loc, val, dst, _volatile, align, order,
+    const mlir::IntegerAttr alignmentAttr = mlir::IntegerAttr::get(
+          mlir::IntegerType::get(dst.getContext(), 64), alignment);
+    return create<cir::StoreOp>(loc, val, dst, _volatile, alignmentAttr, order,
                                 /*tbaa=*/cir::TBAAAttr{});
   }
 

clang/lib/CIR/CodeGen/CIRGenAtomic.cpp

@@ -618,8 +618,7 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
     auto loadVal1 = builder.createLoad(loc, Val1);
     // FIXME(cir): add scope information.
     assert(!cir::MissingFeatures::syncScopeID());
-    builder.createStore(loc, loadVal1, Ptr, E->isVolatile(),
-                        /*alignment=*/mlir::IntegerAttr{}, orderAttr);
+    builder.createStore(loc, loadVal1, Ptr, E->isVolatile(), orderAttr);
     return;
   }
 

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -895,10 +895,19 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
 
   cir::StoreOp createStore(mlir::Location loc, mlir::Value val, Address dst,
                            bool _volatile = false,
-                           ::mlir::IntegerAttr align = {},
                            cir::MemOrderAttr order = {}) {
-    return CIRBaseBuilderTy::createStore(loc, val, dst.getPointer(), _volatile,
-                                         align, order);
+    return createAlignedStore(loc, val, dst.getPointer(), dst.getAlignment(),
+      _volatile, order);
+  }
+
+  cir::StoreOp
+  createAlignedStore(mlir::Location loc, mlir::Value val, mlir::Value dst,
+                     clang::CharUnits align,
+                     bool _volatile = false, cir::MemOrderAttr order = {}) {
+    llvm::MaybeAlign mayAlign = align.getAsAlign();
+    uint64_t alignment = mayAlign ? mayAlign->value() : 0;
+    return CIRBaseBuilderTy::createStore(loc, val, dst, _volatile, alignment,
+                                         order);
   }
 
   cir::StoreOp createFlagStore(mlir::Location loc, bool val, mlir::Value dst) {
@@ -934,21 +943,6 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
     return createVecShuffle(loc, vec1, vec1, mask);
   }
 
-  cir::StoreOp
-  createAlignedStore(mlir::Location loc, mlir::Value val, mlir::Value dst,
-                     clang::CharUnits align = clang::CharUnits::One(),
-                     bool _volatile = false, cir::MemOrderAttr order = {}) {
-    llvm::MaybeAlign mayAlign = align.getAsAlign();
-    mlir::IntegerAttr alignAttr;
-    if (mayAlign) {
-      uint64_t alignment = mayAlign ? mayAlign->value() : 0;
-      alignAttr = mlir::IntegerAttr::get(
-          mlir::IntegerType::get(dst.getContext(), 64), alignment);
-    }
-    return CIRBaseBuilderTy::createStore(loc, val, dst, _volatile, alignAttr,
-                                         order);
-  }
-
   // Convert byte offset to sequence of high-level indices suitable for
   // GlobalViewAttr. Ideally we shouldn't deal with low-level offsets at all
   // but currently some parts of Clang AST, which we don't want to touch just

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -1296,7 +1296,7 @@ void CIRGenFunction::StartFunction(GlobalDecl gd, QualType retTy,
       // Location of the store to the param storage tracked as beginning of
       // the function body.
       auto fnBodyBegin = getLoc(fd->getBody()->getBeginLoc());
-      builder.CIRBaseBuilderTy::createStore(fnBodyBegin, paramVal, addr);
+      builder.createStore(fnBodyBegin, paramVal, address);
     }
     assert(builder.getInsertionBlock() && "Should be valid");
 

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -2031,12 +2031,7 @@ class CIRGenFunction : public CIRGenTypeCache {
     {
       mlir::OpBuilder::InsertionGuard guard(builder);
       builder.restoreInsertionPoint(OutermostConditional->getInsertPoint());
-      builder.createStore(
-          value.getLoc(), value, addr,
-          /*volatile*/ false,
-          mlir::IntegerAttr::get(
-              mlir::IntegerType::get(value.getContext(), 64),
-              (uint64_t)addr.getAlignment().getAsAlign().value()));
+      builder.createStore(value.getLoc(), value, addr);
     }
   }
 

clang/test/CIR/CodeGen/OpenCL/addrspace-alloca.cl

@@ -23,12 +23,12 @@ kernel void func(local int *p) {
   // LLVM-NEXT: %[[#ALLOCA_PTR:]] = alloca ptr, i64 1, align 8
 
   // Store of the argument `p`
-  // CIR-NEXT: cir.store %arg0, %[[#ALLOCA_P]] : !cir.ptr<!s32i, addrspace(offload_local)>, !cir.ptr<!cir.ptr<!s32i, addrspace(offload_local)>, addrspace(offload_private)>
+  // CIR-NEXT: cir.store align(8) %arg0, %[[#ALLOCA_P]] : !cir.ptr<!s32i, addrspace(offload_local)>, !cir.ptr<!cir.ptr<!s32i, addrspace(offload_local)>, addrspace(offload_private)>
   // LLVM-NEXT: store ptr addrspace(3) %{{[0-9]+}}, ptr %[[#ALLOCA_P]], align 8
 
   ptr = &x;
-  // CIR-NEXT: cir.store %[[#ALLOCA_X]], %[[#ALLOCA_PTR]] : !cir.ptr<!s32i, addrspace(offload_private)>, !cir.ptr<!cir.ptr<!s32i, addrspace(offload_private)>, addrspace(offload_private)>
-  // LLVM-NEXT: store ptr %[[#ALLOCA_X]], ptr %[[#ALLOCA_PTR]]
+  // CIR-NEXT: cir.store align(8) %[[#ALLOCA_X]], %[[#ALLOCA_PTR]] : !cir.ptr<!s32i, addrspace(offload_private)>, !cir.ptr<!cir.ptr<!s32i, addrspace(offload_private)>, addrspace(offload_private)>
+  // LLVM-NEXT: store ptr %[[#ALLOCA_X]], ptr %[[#ALLOCA_PTR]], align 8
 
   return;
 }

clang/test/CIR/CodeGen/OpenCL/str_literals.cl

@@ -17,7 +17,7 @@ __constant char *__constant y = "hello world";
 // LLVM: addrspace(2) constant{{.*}}"f\00"
 
 void f() {
-  // CIR: cir.store %{{.*}}, %{{.*}} : !cir.ptr<!s8i, addrspace(offload_constant)>, !cir.ptr<!cir.ptr<!s8i, addrspace(offload_constant)>, addrspace(offload_private)>
-  // LLVM: store ptr addrspace(2) {{.*}}, ptr
+  // CIR: cir.store align(8) %{{.*}}, %{{.*}} : !cir.ptr<!s8i, addrspace(offload_constant)>, !cir.ptr<!cir.ptr<!s8i, addrspace(offload_constant)>, addrspace(offload_private)>
+  // LLVM: store ptr addrspace(2) {{.*}}, ptr {{.*}} align 8
   constant const char *f3 = __func__;
 }