[CIR] Extend CIR canonicalize to rewrite ptr_stride and array_to_ptrdecay to get_element when possible (#1761)

Extended the `CIRCanonicalizePass` with new rewrite rules: 
- Rewrite `ptr_stride (cast array_to_ptrdecay %base), %index` to
`get_element %base[%index]`
- Rewrite `ptr_stride (get_element %base[%index]), %stride` to
`get_element %base[%index + %stride]`
- Rewrite `cast array_to_ptrdecay %base, ptr<T>` to `get_element
%base[0], ptr<T>` if it is only used by `load %ptr : T`, `store %val :
T, %ptr`, or `get_member %ptr[field] : ptr<T> -> U`

Updated CodeGen tests, and extended CIR-to-CIR test.

---------

Co-authored-by: Henrich Lauko <[email protected]>

Author: tommymcm

clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp

@@ -14,6 +14,7 @@
 #include "mlir/IR/Region.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "clang/CIR/Dialect/IR/CIRDataLayout.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/Passes.h"
 
@@ -138,6 +139,77 @@ struct SimplifyCallOp : public OpRewritePattern<CallOp> {
   }
 };
 
+struct SimplifyPtrStrideOp : public OpRewritePattern<PtrStrideOp> {
+  using OpRewritePattern<PtrStrideOp>::OpRewritePattern;
+  LogicalResult matchAndRewrite(PtrStrideOp op,
+                                PatternRewriter &rewriter) const override {
+    mlir::Value base = op.getBase(), index = op.getStride();
+    if (auto castOp = base.getDefiningOp<cir::CastOp>()) {
+      // REWRITE ptr_stride(cast array_to_ptrdecay %base), %index)
+      //      => get_element %base[%index]
+      if (castOp.getKind() != cir::CastKind::array_to_ptrdecay)
+        return mlir::failure();
+
+      base = castOp.getOperand();
+
+    } else if (auto getElemOp = base.getDefiningOp<cir::GetElementOp>()) {
+      // REWRITE ptr_stride(get_element %base[%index]), %stride)
+      //      => get_element %base[%index + %stride]
+      auto elemIndex = getElemOp.getIndex();
+      if (elemIndex.getType() != index.getType())
+        return mlir::failure();
+
+      base = getElemOp.getBase();
+      index = rewriter.create<cir::BinOp>(op->getLoc(), cir::BinOpKind::Add,
+                                          elemIndex, index);
+
+    } else {
+      return mlir::failure();
+    }
+    rewriter.replaceOpWithNewOp<cir::GetElementOp>(op, op.getType(), base,
+                                                   index);
+    return mlir::success();
+  }
+};
+
+struct SimplifyCastOp : public OpRewritePattern<cir::CastOp> {
+  using OpRewritePattern<cir::CastOp>::OpRewritePattern;
+  LogicalResult matchAndRewrite(cir::CastOp op,
+                                PatternRewriter &rewriter) const override {
+    if (op.getKind() != cir::CastKind::array_to_ptrdecay)
+      return mlir::failure();
+
+    auto elemTy = cast<cir::PointerType>(op.getType()).getPointee();
+    for (auto *user : op->getUsers()) {
+      if (auto loadOp = dyn_cast<cir::LoadOp>(user)) {
+        if (elemTy != loadOp.getType())
+          return mlir::failure();
+      } else if (auto storeOp = dyn_cast<cir::StoreOp>(user)) {
+        if (storeOp.getAddr() != op.getResult() ||
+            elemTy != storeOp.getValue().getType())
+          return mlir::failure();
+      } else if (isa<cir::GetMemberOp>(user)) {
+        continue;
+      } else {
+        return mlir::failure();
+      }
+    }
+
+    // REWRITE cast array_to_ptrdecay %base
+    //      => get_element %base[0]
+    auto *context = elemTy.getContext();
+    CIRDataLayout dataLayout(op->getParentOfType<ModuleOp>());
+    auto intType = cast<cir::IntType>(dataLayout.getIntType(context));
+    auto zeroAttr = rewriter.getAttr<cir::IntAttr>(
+        intType, llvm::APInt(intType.getWidth(), 0));
+    auto index = rewriter.create<cir::ConstantOp>(op->getLoc(), zeroAttr);
+
+    rewriter.replaceOpWithNewOp<cir::GetElementOp>(op, op.getType(),
+                                                   op.getOperand(), index);
+    return mlir::success();
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // CIRCanonicalizePass
 //===----------------------------------------------------------------------===//
@@ -163,7 +235,9 @@ void populateCIRCanonicalizePatterns(RewritePatternSet &patterns) {
     RemoveEmptyScope,
     RemoveEmptySwitch,
     RemoveTrivialTry,
-    SimplifyCallOp
+    SimplifyCallOp,
+    SimplifyPtrStrideOp,
+    SimplifyCastOp
   >(patterns.getContext());
   // clang-format on
 }
@@ -181,7 +255,7 @@ void CIRCanonicalizePass::runOnOperation() {
     if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp, CastOp, TryOp, UnaryOp, SelectOp,
             ComplexCreateOp, ComplexRealOp, ComplexImagOp, CallOp, VecCmpOp,
             VecCreateOp, VecExtractOp, VecShuffleOp, VecShuffleDynamicOp,
-            VecTernaryOp>(op))
+            VecTernaryOp, PtrStrideOp>(op))
       ops.push_back(op);
   });
 

clang/test/CIR/CodeGen/OpenCL/array-decay.cl

@@ -19,7 +19,7 @@ kernel void func1(global int *data) {
 // LLVM: @func2
 kernel void func2(global int *data) {
     private int arr[32] = {data[2]};
-    // CIR: %{{[0-9]+}} = cir.cast(array_to_ptrdecay, %{{[0-9]+}} : !cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_private)>), !cir.ptr<!s32i, addrspace(offload_private)>
+    // CIR: %{{[0-9]+}} = cir.get_element %{{[0-9]+}}[%{{[0-9]+}}] : (!cir.ptr<!cir.array<!s32i x 32>, addrspace(offload_private)>, !s32i) -> !cir.ptr<!s32i, addrspace(offload_private)>
 
-    // LLVM: %{{[0-9]+}} = getelementptr i32, ptr %3, i32 0
+    // LLVM: %{{[0-9]+}} = getelementptr [32 x i32], ptr %3, i32 0, i64 0
 }

clang/test/CIR/CodeGen/array-init.c

@@ -10,24 +10,30 @@ typedef struct {
 } T;
 
 void buz(int x) {
-  T arr[] = { {0, x}, {0, 0} };
+  T arr[] = { {x, x}, {0, 0} };
 }
 // CIR: cir.func dso_local @buz
 // CIR-NEXT: [[X_ALLOCA:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
 // CIR-NEXT: [[ARR:%.*]] = cir.alloca !cir.array<!rec_T x 2>, !cir.ptr<!cir.array<!rec_T x 2>>, ["arr", init] {alignment = 16 : i64}
 // CIR-NEXT: cir.store{{.*}} %arg0, [[X_ALLOCA]] : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: [[ARR_INIT:%.*]] = cir.const #cir.zero : !cir.array<!rec_T x 2>
-// CIR-NEXT: cir.store{{.*}} [[ARR_INIT]], [[ARR]] : !cir.array<!rec_T x 2>, !cir.ptr<!cir.array<!rec_T x 2>>
-// CIR-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!rec_T x 2>>), !cir.ptr<!rec_T>
+// CIR-NEXT: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR-NEXT: [[FI_EL:%.*]] = cir.get_element [[ARR]][[[ZERO]]] : (!cir.ptr<!cir.array<!rec_T x 2>>, !s32i) -> !cir.ptr<!rec_T>
 // CIR-NEXT: [[A_STORAGE0:%.*]] = cir.get_member [[FI_EL]][0] {name = "a"} : !cir.ptr<!rec_T> -> !cir.ptr<!s32i>
+// CIR-NEXT: [[XA_VAL:%.*]] = cir.load{{.*}} [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: cir.store{{.*}} [[XA_VAL]], [[A_STORAGE0]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[B_STORAGE0:%.*]] = cir.get_member [[FI_EL]][1] {name = "b"} : !cir.ptr<!rec_T> -> !cir.ptr<!s64i>
-// CIR-NEXT: [[X_VAL:%.*]] = cir.load{{.*}} [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: [[X_CASTED:%.*]] = cir.cast(integral, [[X_VAL]] : !s32i), !s64i
-// CIR-NEXT: cir.store{{.*}} [[X_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr<!s64i>
+// CIR-NEXT: [[XB_VAL:%.*]] = cir.load{{.*}} [[X_ALLOCA]] : !cir.ptr<!s32i>, !s32i
+// CIR-NEXT: [[XB_CASTED:%.*]] = cir.cast(integral, [[XB_VAL]] : !s32i), !s64i
+// CIR-NEXT: cir.store{{.*}} [[XB_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr<!s64i>
 // CIR-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
-// CIR-NEXT: [[SE_EL:%.*]] = cir.ptr_stride([[FI_EL]] : !cir.ptr<!rec_T>, [[ONE]] : !s64i), !cir.ptr<!rec_T>
+// CIR-NEXT: [[SE_EL:%.*]] = cir.get_element [[ARR]][[[ONE]]] : (!cir.ptr<!cir.array<!rec_T x 2>>, !s64i) -> !cir.ptr<!rec_T>
 // CIR-NEXT: [[A_STORAGE1:%.*]] = cir.get_member [[SE_EL]][0] {name = "a"} : !cir.ptr<!rec_T> -> !cir.ptr<!s32i>
+// CIR-NEXT: [[A1_ZERO:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR-NEXT: cir.store{{.*}} [[A1_ZERO]], [[A_STORAGE1]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[B_STORAGE1:%.*]] = cir.get_member [[SE_EL]][1] {name = "b"} : !cir.ptr<!rec_T> -> !cir.ptr<!s64i>
+// CIR-NEXT: [[B1_ZERO:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR-NEXT: [[B1_CASTED:%.*]] = cir.cast(integral, [[B1_ZERO]] : !s32i), !s64i
+// CIR-NEXT: cir.store{{.*}} [[B1_CASTED]], [[B_STORAGE1]] : !s64i, !cir.ptr<!s64i>
 // CIR-NEXT: cir.return
 
 void foo() {
@@ -46,34 +52,36 @@ void bar(int a, int b, int c) {
 // CIR-NEXT: cir.store{{.*}} %arg0, [[A:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: cir.store{{.*}} %arg1, [[B:%.*]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: cir.store{{.*}} %arg2, [[C:%.*]] : !s32i, !cir.ptr<!s32i>
-// CIR-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+// CIR-NEXT: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR-NEXT: [[ELEM0:%.*]] = cir.get_element [[ARR]][[[ZERO]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s32i) -> !cir.ptr<!s32i>
 // CIR-NEXT: [[LOAD_A:%.*]] = cir.load{{.*}} [[A]] : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: cir.store{{.*}} [[LOAD_A]], [[FI_EL]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store{{.*}} [[LOAD_A]], [[ELEM0]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
-// CIR-NEXT: [[SE_EL:%.*]] = cir.ptr_stride(%4 : !cir.ptr<!s32i>, [[ONE]] : !s64i), !cir.ptr<!s32i>
+// CIR-NEXT: [[ELEM1:%.*]] = cir.get_element [[ARR]][[[ONE]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s64i) -> !cir.ptr<!s32i>
 // CIR-NEXT: [[LOAD_B:%.*]] = cir.load{{.*}} [[B]] : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: cir.store{{.*}} [[LOAD_B]], [[SE_EL]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store{{.*}} [[LOAD_B]], [[ELEM1]] : !s32i, !cir.ptr<!s32i>
 // CIR-NEXT: [[TWO:%.*]] = cir.const #cir.int<2> : !s64i
-// CIR-NEXT: [[TH_EL:%.*]] = cir.ptr_stride(%4 : !cir.ptr<!s32i>, [[TWO]] : !s64i), !cir.ptr<!s32i>
+// CIR-NEXT: [[ELEM2:%.*]] = cir.get_element [[ARR]][[[TWO]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s64i) -> !cir.ptr<!s32i>
 // CIR-NEXT: [[LOAD_C:%.*]] = cir.load{{.*}} [[C]] : !cir.ptr<!s32i>, !s32i
-// CIR-NEXT: cir.store{{.*}} [[LOAD_C]], [[TH_EL]] : !s32i, !cir.ptr<!s32i>
+// CIR-NEXT: cir.store{{.*}} [[LOAD_C]], [[ELEM2]] : !s32i, !cir.ptr<!s32i>
 
 void zero_init(int x) {
   int arr[3] = {x};
 }
 // CIR:  cir.func dso_local @zero_init
 // CIR:    [[VAR_ALLOC:%.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] {alignment = 4 : i64}
-// CIR:    %1 = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["arr", init] {alignment = 4 : i64}
+// CIR:    [[ARR:%.*]] = cir.alloca !cir.array<!s32i x 3>, !cir.ptr<!cir.array<!s32i x 3>>, ["arr", init] {alignment = 4 : i64}
 // CIR:    [[TEMP:%.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arrayinit.temp", init] {alignment = 8 : i64}
 // CIR:    cir.store{{.*}} %arg0, [[VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
-// CIR:    [[BEGIN:%.*]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 3>>), !cir.ptr<!s32i>
+// CIR:    [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR:    [[BEGIN:%.*]] = cir.get_element [[ARR]][[[ZERO]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s32i) -> !cir.ptr<!s32i>
 // CIR:    [[VAR:%.*]] = cir.load{{.*}} [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
 // CIR:    cir.store{{.*}} [[VAR]], [[BEGIN]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
-// CIR:    [[ZERO_INIT_START:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[ONE]] : !s64i), !cir.ptr<!s32i>
+// CIR:    [[ZERO_INIT_START:%.*]] = cir.get_element [[ARR]][[[ONE]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s64i) -> !cir.ptr<!s32i>
 // CIR:    cir.store{{.*}} [[ZERO_INIT_START]], [[TEMP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CIR:    [[SIZE:%.*]] = cir.const #cir.int<3> : !s64i
-// CIR:    [[END:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[SIZE]] : !s64i), !cir.ptr<!s32i>
+// CIR:    [[END:%.*]] = cir.get_element [[ARR]][[[SIZE]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s64i) -> !cir.ptr<!s32i>
 // CIR:    cir.do {
 // CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[FILLER:%.*]] = cir.const #cir.int<0> : !s32i
@@ -99,26 +107,28 @@ void aggr_init() {
 // CIR:    [[TEMP:%.*]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arrayinit.temp", init] {alignment = 8 : i64}
 // CIR:    %3 = cir.const #cir.int<5> : !s32i
 // CIR:    cir.store{{.*}} %3, [[VAR_ALLOC]] : !s32i, !cir.ptr<!s32i>
-// CIR:    [[BEGIN:%.*]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s32i x 5>>), !cir.ptr<!s32i>
-// CIR:    %5 = cir.const #cir.int<1> : !s32i
-// CIR:    cir.store{{.*}} %5, [[BEGIN]] : !s32i, !cir.ptr<!s32i>
-// CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s64i
-// CIR:    %7 = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[ONE]] : !s64i), !cir.ptr<!s32i>
-// CIR:    %8 = cir.const #cir.int<2> : !s32i
-// CIR:    cir.store{{.*}} %8, %7 : !s32i, !cir.ptr<!s32i>
-// CIR:    [[TWO:%.*]] = cir.const #cir.int<2> : !s64i
-// CIR:    %10 = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[TWO]] : !s64i), !cir.ptr<!s32i>
-// CIR:    %11 = cir.const #cir.int<3> : !s32i
-// CIR:    cir.store{{.*}} %11, %10 : !s32i, !cir.ptr<!s32i>
-// CIR:    [[THREE:%.*]] = cir.const #cir.int<3> : !s64i
-// CIR:    %13 = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[THREE]] : !s64i), !cir.ptr<!s32i>
+// CIR:    [[OFFSET0:%.*]] = cir.const #cir.int<0> : !s32i
+// CIR:    [[BEGIN:%.*]] = cir.get_element %1[[[OFFSET0]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s32i) -> !cir.ptr<!s32i>
+// CIR:    [[ONE:%.*]] = cir.const #cir.int<1> : !s32i
+// CIR:    cir.store{{.*}} [[ONE]], [[BEGIN]] : !s32i, !cir.ptr<!s32i>
+// CIR:    [[OFFSET1:%.*]] = cir.const #cir.int<1> : !s64i
+// CIR:    [[ELEM1:%.*]] = cir.get_element %1[[[OFFSET1]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!s32i>
+// CIR:    [[TWO:%.*]] = cir.const #cir.int<2> : !s32i
+// CIR:    cir.store{{.*}} [[TWO]], [[ELEM1]] : !s32i, !cir.ptr<!s32i>
+// CIR:    [[OFFSET2:%.*]] = cir.const #cir.int<2> : !s64i
+// CIR:    [[ELEM2:%.*]] = cir.get_element %1[[[OFFSET2]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!s32i>
+// CIR:    [[THREE:%.*]] = cir.const #cir.int<3> : !s32i
+// CIR:    cir.store{{.*}} [[THREE]], [[ELEM2]] : !s32i, !cir.ptr<!s32i>
+// CIR:    [[OFFSET3:%.*]] = cir.const #cir.int<3> : !s64i
+// CIR:    [[ELEM3:%.*]] = cir.get_element %1[[[OFFSET3]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!s32i>
 // CIR:    [[VAR:%.*]] = cir.load{{.*}} [[VAR_ALLOC]] : !cir.ptr<!s32i>, !s32i
-// CIR:    cir.store{{.*}} [[VAR]], %13 : !s32i, !cir.ptr<!s32i>
+// CIR:    cir.store{{.*}} [[VAR]], [[ELEM3]] : !s32i, !cir.ptr<!s32i>
 // CIR:    [[ONE_VAR:%.*]] = cir.const #cir.int<1> : !s64i
-// CIR:    %16 = cir.ptr_stride(%13 : !cir.ptr<!s32i>, [[ONE_VAR]] : !s64i), !cir.ptr<!s32i>
-// CIR:    cir.store{{.*}} %16, [[TEMP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
+// CIR:    [[OFFSET4:%.*]] = cir.binop(add, [[OFFSET3]], [[ONE_VAR]]) : !s64i
+// CIR:    [[LAST:%.*]] = cir.get_element %1[[[OFFSET4]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!s32i>
+// CIR:    cir.store{{.*}} [[LAST]], [[TEMP]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CIR:    [[SIZE:%.*]] = cir.const #cir.int<5> : !s64i
-// CIR:    [[END:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr<!s32i>, [[SIZE]] : !s64i), !cir.ptr<!s32i>
+// CIR:    [[END:%.*]] = cir.get_element %1[[[SIZE]]] : (!cir.ptr<!cir.array<!s32i x 5>>, !s64i) -> !cir.ptr<!s32i>
 // CIR:    cir.do {
 // CIR:      [[CUR:%.*]] = cir.load{{.*}} [[TEMP]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CIR:      [[FILLER:%.*]] = cir.const #cir.int<0> : !s32i
@@ -139,18 +149,18 @@ void aggr_init() {
 // LLVM:   %2 = alloca [5 x i32], i64 1, align 16
 // LLVM:   [[TEMP:%.*]] = alloca ptr, i64 1, align 8
 // LLVM:   store i32 5, ptr [[VAR_ALLOC]], align 4
-// LLVM:   [[BEGIN:%.*]] = getelementptr i32, ptr %2, i32 0
+// LLVM:   [[BEGIN:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 0
 // LLVM:   store i32 1, ptr [[BEGIN]], align 4
-// LLVM:   [[ONE:%.*]] = getelementptr i32, ptr [[BEGIN]], i64 1
+// LLVM:   [[ONE:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 1
 // LLVM:   store i32 2, ptr [[ONE]], align 4
-// LLVM:   [[TWO:%.*]] = getelementptr i32, ptr [[BEGIN]], i64 2
+// LLVM:   [[TWO:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 2
 // LLVM:   store i32 3, ptr [[TWO]], align 4
-// LLVM:   [[THREE:%.*]] = getelementptr i32, ptr [[BEGIN]], i64 3
+// LLVM:   [[THREE:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 3
 // LLVM:   [[VAR:%.*]] = load i32, ptr [[VAR_ALLOC]], align 4
 // LLVM:   store i32 [[VAR]], ptr [[THREE]], align 4
-// LLVM:   %9 = getelementptr i32, ptr [[THREE]], i64 1
-// LLVM:   store ptr %9, ptr [[TEMP]], align 8
-// LLVM:   [[END:%.*]] = getelementptr i32, ptr [[BEGIN]], i64 5
+// LLVM:   [[LAST:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 4
+// LLVM:   store ptr [[LAST]], ptr [[TEMP]], align 8
+// LLVM:   [[END:%.*]] = getelementptr [5 x i32], ptr %2, i32 0, i64 5
 // LLVM:   br label %14
 //
 // LLVM: 11:                                               ; preds = %14

clang/test/CIR/CodeGen/array-init.cpp

@@ -22,7 +22,7 @@ void foo() {
 // CHECK: %[[VAL_5:.*]] = cir.cast(array_to_ptrdecay, %[[VAL_4]] : !cir.ptr<!cir.array<!s32i x 2>>), !cir.ptr<!s32i>
 // CHECK: cir.store{{.*}} %[[VAL_5]], %[[VAL_1]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 // CHECK: %[[VAL_6:.*]] = cir.const #cir.int<2> : !s64i
-// CHECK: %[[VAL_7:.*]] = cir.ptr_stride(%[[VAL_5]] : !cir.ptr<!s32i>, %[[VAL_6]] : !s64i), !cir.ptr<!s32i>
+// CHECK: %[[VAL_7:.*]] = cir.get_element %[[VAL_4]][%[[VAL_6]]] : (!cir.ptr<!cir.array<!s32i x 2>>, !s64i) -> !cir.ptr<!s32i>
 // CHECK: cir.do {
 // CHECK:     %[[VAL_8:.*]] = cir.load{{.*}} %[[VAL_1]] : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
 // CHECK:     %[[VAL_9:.*]] = cir.const #cir.int<0> : !s32i

clang/test/CIR/CodeGen/array.cpp

@@ -70,20 +70,24 @@ struct S {
 
 void testPointerDecaySubscriptAccess(int arr[]) {
 // CHECK: cir.func dso_local @{{.+}}testPointerDecaySubscriptAccess
-  arr[1];
+  arr[1] = 2;
+  // CHECK: %[[#TWO:]] = cir.const #cir.int<2> : !s32i
   // CHECK: %[[#BASE:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
   // CHECK: %[[#DIM1:]] = cir.const #cir.int<1> : !s32i
-  // CHECK: cir.ptr_stride(%[[#BASE]] : !cir.ptr<!s32i>, %[[#DIM1]] : !s32i), !cir.ptr<!s32i>
+  // CHECK: %[[#ELEM:]] = cir.ptr_stride(%[[#BASE]] : !cir.ptr<!s32i>, %[[#DIM1]] : !s32i), !cir.ptr<!s32i>
+  // CHECK: cir.store{{.*}} %[[#TWO]], %[[#ELEM]] : !s32i, !cir.ptr<!s32i>
 }
 
 void testPointerDecayedArrayMultiDimSubscriptAccess(int arr[][3]) {
 // CHECK: cir.func dso_local @{{.+}}testPointerDecayedArrayMultiDimSubscriptAccess
-  arr[1][2];
+  arr[1][2] = 3;
+  // CHECK: %[[#THREE:]] = cir.const #cir.int<3> : !s32i
   // CHECK: %[[#ARRAY:]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!cir.array<!s32i x 3>>>, !cir.ptr<!cir.array<!s32i x 3>>
   // CHECK: %[[#ONE:]] = cir.const #cir.int<1> : !s32i
   // CHECK: %[[#OUTER:]] = cir.ptr_stride(%[[#ARRAY]] : !cir.ptr<!cir.array<!s32i x 3>>, %[[#ONE]] : !s32i), !cir.ptr<!cir.array<!s32i x 3>>
   // CHECK: %[[#TWO:]] = cir.const #cir.int<2> : !s32i
   // CHECK: %[[#INNER:]] = cir.get_element %[[#OUTER]][%[[#TWO]]] : (!cir.ptr<!cir.array<!s32i x 3>>, !s32i) -> !cir.ptr<!s32i>
+  // CHECK: cir.store{{.*}} %[[#THREE]], %[[#INNER]] : !s32i, !cir.ptr<!s32i>
 }
 
 void testArrayOfComplexType() { int _Complex a[4]; }

clang/test/CIR/CodeGen/clear_cache.c

@@ -13,9 +13,8 @@ char buffer[32] = "This is a largely unused buffer";
 // CIR:  %[[VAL_2:.*]] = cir.cast(array_to_ptrdecay, %[[VAL_1]] : !cir.ptr<!cir.array<!s8i x 32>>), !cir.ptr<!s8i>
 // CIR:  %[[VAL_3:.*]] = cir.cast(bitcast, %[[VAL_2]] : !cir.ptr<!s8i>), !cir.ptr<!void>
 // CIR:  %[[VAL_4:.*]] = cir.get_global @buffer : !cir.ptr<!cir.array<!s8i x 32>>
-// CIR:  %[[VAL_5:.*]] = cir.cast(array_to_ptrdecay, %[[VAL_4]] : !cir.ptr<!cir.array<!s8i x 32>>), !cir.ptr<!s8i>
 // CIR:  %[[VAL_6:.*]] = cir.const #cir.int<32> : !s32i
-// CIR:  %[[VAL_7:.*]] = cir.ptr_stride(%[[VAL_5]] : !cir.ptr<!s8i>, %[[VAL_6]] : !s32i), !cir.ptr<!s8i>
+// CIR:  %[[VAL_7:.*]] = cir.get_element %[[VAL_4]][%[[VAL_6]]] : (!cir.ptr<!cir.array<!s8i x 32>>, !s32i) -> !cir.ptr<!s8i>
 // CIR:  %[[VAL_8:.*]] = cir.cast(bitcast, %[[VAL_7]] : !cir.ptr<!s8i>), !cir.ptr<!void>
 // CIR:  cir.clear_cache %[[VAL_3]] : !cir.ptr<!void>, %[[VAL_8]],