// Test for the array-value-copy pass
// RUN: fir-opt --split-input-file --array-value-copy %s | FileCheck %s

// Test simple fir.array_load/fir.array_fetch conversion to fir.array_coor
func.func @array_fetch_conversion(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m: index, %n: index) {
  %c10 = arith.constant 10 : index
  %c20 = arith.constant 20 : index
  %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
  %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
  %f = fir.array_fetch %av1, %c10, %c20 : (!fir.array<?x?xf32>, index, index) -> f32
  return
}

// CHECK-LABEL: func @array_fetch_conversion(
// CHECK-SAME:                               %[[ARRAY:.*]]: !fir.ref<!fir.array<?x?xf32>>,
// CHECK-SAME:                               %[[ARG1:.*]]: index,
// CHECK-SAME:                               %[[ARG2:.*]]: index) {
// CHECK:         %{{.*}} = fir.shape %[[ARG1]], %[[ARG2]] : (index, index) -> !fir.shape<2>
// CHECK:         %{{.*}} = fir.undefined !fir.array<?x?xf32>
// CHECK:         %[[VAL_0:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK:         %[[VAL_1:.*]] = arith.addi %{{.*}}, %{{.*}} : index
// CHECK-NOT:     fir.array_load
// CHECK-NOT:     fir.array_fetch
// CHECK:         %{{.*}} = fir.array_coor %arg0(%0) %[[VAL_0]], %[[VAL_1]] : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, index, index) -> !fir.ref<f32>
// CHECK:         %{{.*}} = fir.load %4 : !fir.ref<f32>

// -----

// Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out
func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
  %c10 = arith.constant 10 : index
  %c20 = arith.constant 20 : index
  %c1 = arith.constant 1 : index
  %f = arith.constant 2.0 : f32
  %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
  %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
  %av2 = fir.array_update %av1, %f, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
  return
}

// CHECK-LABEL: func @array_update_conversion
// CHECK-NOT:     fir.array_load
// CHECK-NOT:     fir.array_update
// CHECK:         %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
// CHECK:         %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
// CHECK:         %[[ARRAY_COOR:.*]] = fir.array_coor{{.*}}-> !fir.ref<f32>
// CHECK:         fir.store %{{.*}} to %[[ARRAY_COOR]] : !fir.ref<f32>

// -----

// Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out
func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index, %cond: i1) {
  %c10 = arith.constant 10 : index
  %c20 = arith.constant 20 : index
  %c1 = arith.constant 1 : index
  %f = arith.constant 2.0 : f32
  %g = arith.constant 4.0 : f32
  %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
  %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
  fir.if %cond {
    %av2 = fir.array_update %av1, %f, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
  } else {
    %av2 = fir.array_update %av1, %g, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
  }
  return
}

// -----

// Test fir.array_load/fir.array_fetch/fir.array_update conversion with
// an introduced copy-in/copy-out.
// 
// This test corresponds to a simplified FIR version of the following Fortran
// code.
// ```
//   integer :: i(10)
//   i = i(10:1:-1)
//  end
// ```

func.func @conversion_with_temporary(%arr0 : !fir.ref<!fir.array<10xi32>>) {
  %c10 = arith.constant 10 : index
  %1 = fir.shape %c10 : (index) -> !fir.shape<1>
  %2 = fir.array_load %arr0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.array<10xi32>
  %c10_i64 = arith.constant 10 : i64
  %3 = fir.convert %c10_i64 : (i64) -> index
  %c1_i64 = arith.constant 1 : i64
  %c-1_i64 = arith.constant -1 : i64
  %4 = fir.shape %c10 : (index) -> !fir.shape<1>
  %5 = fir.slice %c10_i64, %c1_i64, %c-1_i64 : (i64, i64, i64) -> !fir.slice<1>
  %6 = fir.array_load %arr0(%4) [%5] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<10xi32>
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %7 = arith.subi %3, %c1 : index
  %8 = fir.do_loop %arg0 = %c0 to %7 step %c1 unordered iter_args(%arg1 = %2) -> (!fir.array<10xi32>) {
    %9 = fir.array_fetch %6, %arg0 : (!fir.array<10xi32>, index) -> i32
    %10 = fir.array_update %arg1, %9, %arg0 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
    fir.result %10 : !fir.array<10xi32>
  }
  fir.array_merge_store %2, %8 to %arr0 : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>
  return
}

// CHECK-LABEL: func @conversion_with_temporary(
// CHECK-SAME:                                  %[[ARR0:.*]]: !fir.ref<!fir.array<10xi32>>)
// Allocation of temporary array.
// CHECK:         %[[TEMP:.*]] = fir.allocmem !fir.array<10xi32>
// Copy of original array to temp.
// CHECK:         fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         }
// Perform the assignment i = i(10:1:-1) using the temporary array.
// CHECK:         %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) {
// CHECK-NOT:       %{{.*}} = fir.array_fetch
// CHECK-NOT:       %{{.*}} = fir.array_update
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:           fir.result %{{.*}} : !fir.array<10xi32>
// CHECK:         }
// Copy the result back to the original array.
// CHECK:         fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0:.*]] : !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         }
// Free temporary array.
// CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10xi32>>

// -----

// Test fir.array_load/fir.array_fetch/fir.array_update conversion with
// an introduced copy-in/copy-out on a multidimensional array.

func.func @conversion_with_temporary_multidim(%0: !fir.ref<!fir.array<10x5xi32>>) {
  %c10 = arith.constant 10 : index
  %c5 = arith.constant 5 : index
  %1 = fir.shape %c10, %c5 : (index, index) -> !fir.shape<2>
  %2 = fir.array_load %0(%1) : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>) -> !fir.array<10x5xi32>
  %c10_i64 = arith.constant 10 : i64
  %3 = fir.convert %c10_i64 : (i64) -> index
  %c5_i64 = arith.constant 5 : i64
  %4 = fir.convert %c5_i64 : (i64) -> index
  %c1 = arith.constant 1 : index
  %c10_i64_0 = arith.constant 10 : i64
  %c1_i64 = arith.constant 1 : i64
  %c-1_i64 = arith.constant -1 : i64
  %5 = arith.addi %c1, %c5 : index
  %6 = arith.subi %5, %c1 : index
  %c1_i64_1 = arith.constant 1 : i64
  %7 = fir.shape %c10, %c5 : (index, index) -> !fir.shape<2>
  %8 = fir.slice %c10_i64_0, %c1_i64, %c-1_i64, %c1, %6, %c1_i64_1 : (i64, i64, i64, index, index, i64) -> !fir.slice<2>
  %9 = fir.array_load %0(%7) [%8] : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.array<10x5xi32>
  %c1_2 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %10 = arith.subi %3, %c1_2 : index
  %11 = arith.subi %4, %c1_2 : index
  %12 = fir.do_loop %arg0 = %c0 to %11 step %c1_2 unordered iter_args(%arg1 = %2) -> (!fir.array<10x5xi32>) {
    %13 = fir.do_loop %arg2 = %c0 to %10 step %c1_2 unordered iter_args(%arg3 = %arg1) -> (!fir.array<10x5xi32>) {
      %14 = fir.array_fetch %9, %arg2, %arg0 : (!fir.array<10x5xi32>, index, index) -> i32
      %15 = fir.array_update %arg3, %14, %arg2, %arg0 : (!fir.array<10x5xi32>, i32, index, index) -> !fir.array<10x5xi32>
      fir.result %15 : !fir.array<10x5xi32>
    }
    fir.result %13 : !fir.array<10x5xi32>
  }
  fir.array_merge_store %2, %12 to %0 : !fir.array<10x5xi32>, !fir.array<10x5xi32>, !fir.ref<!fir.array<10x5xi32>>
  return
}

// CHECK-LABEL: func @conversion_with_temporary_multidim(
// CHECK-SAME:                                           %[[ARR0:.*]]: !fir.ref<!fir.array<10x5xi32>>) {
// CHECK:         %[[CST10:.*]] = arith.constant 10 : index
// CHECK:         %[[CST5:.*]] = arith.constant 5 : index
// CHECK:         %[[TEMP:.*]] = fir.allocmem !fir.array<10x5xi32>
// CHECK:         %[[IDX5:.*]] = fir.convert %[[CST5]] : (index) -> index
// CHECK:         %[[UB5:.*]] = arith.subi %[[IDX5]], %{{.*}} : index
// CHECK:         fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} {
// CHECK:           %[[IDX10:.*]] = fir.convert %[[CST10]] : (index) -> index
// CHECK:           %[[UB10:.*]] = arith.subi %[[IDX10]], %{{.*}} : index
// CHECK:           fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} {
// CHECK:             %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index
// CHECK:             %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %[[IDX1:.*]], %[[IDX2:.*]] : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         %{{.*}} = fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) {
// CHECK:           %{{.*}} = fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10x5xi32>) {
// CHECK:             %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index
// CHECK:             %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index
// CHECK-NOT:         %{{.*}} = fir.array_fetch
// CHECK-NOT:         %{{.*}} = fir.array_update
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) [%{{.*}}] %[[IDX1]], %[[IDX2]] : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>, !fir.slice<2>, index, index) -> !fir.ref<i32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
// CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         %[[IDX5:.*]] = fir.convert %[[CST5]] : (index) -> index
// CHECK:         %[[UB5:.*]] = arith.subi %[[IDX5]], %{{.*}} : index
// CHECK:         fir.do_loop %[[INDUC0:.*]] = %{{.*}} to %[[UB5]] step %{{.*}} {
// CHECK:           %[[IDX10:.*]] = fir.convert %[[CST10]] : (index) -> index
// CHECK:           %[[UB10:.*]] = arith.subi %[[IDX10]], %{{.*}} : index
// CHECK:           fir.do_loop %[[INDUC1:.*]] = %{{.*}} to %[[UB10]] step %{{.*}} {
// CHECK:             %[[IDX1:.*]] = arith.addi %[[INDUC1]], %{{.*}} : index
// CHECK:             %[[IDX2:.*]] = arith.addi %[[INDUC0]], %{{.*}} : index  
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %[[IDX1]], %[[IDX2]] : (!fir.heap<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<10x5xi32>>, !fir.shape<2>, index, index) -> !fir.ref<i32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10x5xi32>>

// -----

// Test fir.array_modify conversion with no overlap.
func.func @array_modify_no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
  %c100 = arith.constant 100 : index
  %c99 = arith.constant 99 : index
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %0 = fir.alloca f32
  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
  %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
  %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
  %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {
    %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32
    %6:2 = fir.array_modify %arg3, %arg2 : (!fir.array<100xf32>, index) -> (!fir.ref<f32>, !fir.array<100xf32>)
    fir.store %5 to %0 : !fir.ref<f32>
    fir.call @user_defined_assignment(%6#0, %0) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
    fir.result %6#1 : !fir.array<100xf32>
  }
  fir.array_merge_store %2, %4 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
  return
}

func.func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)

// CHECK-LABEL:   func @array_modify_no_overlap(
// CHECK-SAME:                                  %[[ARR0:.*]]: !fir.ref<!fir.array<100xf32>>,
// CHECK-SAME:                                  %[[ARR1:.*]]: !fir.ref<!fir.array<100xf32>>) {
// CHECK:           %[[VAR0:.*]] = fir.alloca f32
// CHECK-COUNT-1:   %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<100xf32>) {
// CHECK-NOT:       %{{.*}} = fir.array_fetch
// CHECK-NOT:       %{{.*}} = fir.array_modify
// CHECK:           %[[COOR0:.*]] = fir.array_coor %arg1(%1) %5 : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<f32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:           fir.store %[[LOAD0]] to %[[VAR0]] : !fir.ref<f32>
// CHECK:           fir.call @{{.*}}(%[[COOR1]], %[[VAR0]]) : (!fir.ref<f32>, !fir.ref<f32>) -> ()

// -----

// Test fir.array_modify conversion with an overlap.
// Test user_defined_assignment(arg0(:), arg0(100:1:-1))
func.func @array_modify_overlap(%arg0: !fir.ref<!fir.array<100xf32>>) {
  %c100 = arith.constant 100 : index
  %c99 = arith.constant 99 : index
  %c1 = arith.constant 1 : index
  %c-1 = arith.constant -1 : index
  %c0 = arith.constant 0 : index
  %0 = fir.alloca f32
  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
  %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
  %3 = fir.slice %c100, %c1, %c-1 : (index, index, index) -> !fir.slice<1>
  %4 = fir.array_load %arg0(%1) [%3] : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<100xf32>
  %5 = fir.do_loop %arg1 = %c0 to %c99 step %c1 unordered iter_args(%arg2 = %2) -> (!fir.array<100xf32>) {
    %6 = fir.array_fetch %4, %arg1 : (!fir.array<100xf32>, index) -> f32
    %7:2 = fir.array_modify %arg2, %arg1 : (!fir.array<100xf32>, index) -> (!fir.ref<f32>, !fir.array<100xf32>)
    fir.store %6 to %0 : !fir.ref<f32>
    fir.call @user_defined_assignment(%7#0, %0) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
    fir.result %7#1 : !fir.array<100xf32>
  }
  fir.array_merge_store %2, %5 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
  return
}

func.func private @user_defined_assignment(!fir.ref<f32>, !fir.ref<f32>)

// CHECK-LABEL:   func @array_modify_overlap(
// CHECK-SAME:                               %[[ARR0:.*]]: !fir.ref<!fir.array<100xf32>>) {
// CHECK:           %[[VAR0:.*]] = fir.alloca f32
// Allocate the temporary array.
// CHECK:           %[[TEMP:.*]] = fir.allocmem !fir.array<100xf32>
// Copy original array to temp.
// CHECK:           fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<f32>
// CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<f32>
// CHECK:           }
// CHECK:           %[[VAL_21:.*]] = fir.undefined !fir.array<100xf32>
// CHECK:           %[[VAL_23:.*]] = fir.undefined !fir.array<100xf32>
// CHECK-NOT:         %{{.*}} = fir.array_fetch
// CHECK-NOT:         %{{.*}} = fir.array_modify
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) {{\[}}%{{.*}}] %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<f32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<f32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:             fir.store %[[LOAD0]] to %[[VAR0]] : !fir.ref<f32>
// CHECK:             fir.call @user_defined_assignment(%[[COOR1]], %[[VAR0]]) : (!fir.ref<f32>, !fir.ref<f32>) -> ()
// CHECK:           }
// Copy back result to original array from temp.
// CHECK:           fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:             %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:             %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:             %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<f32>
// CHECK:             fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<f32>
// CHECK:           }
// Free the temporary array.
// CHECK:           fir.freemem %[[TEMP]] : !fir.heap<!fir.array<100xf32>>
// CHECK:           return
// CHECK:         }

// -----

// Test array of types with no overlap
func.func @array_of_types() {
  %0 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QEj"}
  %1 = fir.address_of(@_QEtypes) : !fir.ref<!fir.array<10x!fir.type<_QTd{i:!fir.array<10xi32>}>>>
  %c1_i32 = arith.constant 1 : i32
  %2 = fir.convert %c1_i32 : (i32) -> index
  %c10_i32 = arith.constant 10 : i32
  %3 = fir.convert %c10_i32 : (i32) -> index
  %c1 = arith.constant 1 : index
  %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index {
    %6 = fir.convert %arg0 : (index) -> i32
    fir.store %6 to %0 : !fir.ref<i32>
    %c1_0 = arith.constant 1 : index
    %7 = fir.load %0 : !fir.ref<i32>
    %8 = fir.convert %7 : (i32) -> i64
    %c1_i64 = arith.constant 1 : i64
    %9 = arith.subi %8, %c1_i64 : i64
    %10 = fir.coordinate_of %1, %9 : (!fir.ref<!fir.array<10x!fir.type<_QTd{i:!fir.array<10xi32>}>>>, i64) -> !fir.ref<!fir.type<_QTd{i:!fir.array<10xi32>}>>
    %11 = fir.field_index i, !fir.type<_QTd{i:!fir.array<10xi32>}>
    %12 = fir.coordinate_of %10, %11 : (!fir.ref<!fir.type<_QTd{i:!fir.array<10xi32>}>>, !fir.field) -> !fir.ref<!fir.array<10xi32>>
    %c10 = arith.constant 10 : index
    %13 = arith.addi %c1_0, %c10 : index
    %14 = arith.subi %13, %c1_0 : index
    %c1_i64_1 = arith.constant 1 : i64
    %15 = fir.shape %c10 : (index) -> !fir.shape<1>
    %16 = fir.slice %c1_0, %14, %c1_i64_1 : (index, index, i64) -> !fir.slice<1>
    %17 = fir.array_load %12(%15) [%16] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<10xi32>
    %c10_i64 = arith.constant 10 : i64
    %18 = fir.convert %c10_i64 : (i64) -> index
    %c0_i32 = arith.constant 0 : i32
    %c1_2 = arith.constant 1 : index
    %c0 = arith.constant 0 : index
    %19 = arith.subi %18, %c1_2 : index
    %20 = fir.do_loop %arg1 = %c0 to %19 step %c1_2 unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) {
      %22 = fir.array_update %arg2, %c0_i32, %arg1 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
      fir.result %22 : !fir.array<10xi32>
    }
    fir.array_merge_store %17, %20 to %12[%16] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.ref<!fir.array<10xi32>>, !fir.slice<1>
    %21 = arith.addi %arg0, %c1 : index
    fir.result %21 : index
  }
  %5 = fir.convert %4 : (index) -> i32
  fir.store %5 to %0 : !fir.ref<i32>
  return
}

// CHECK-LABEL: func @array_of_types() {
// CHECK:         %{{.*}} = fir.do_loop %{{.*}} = %{{.*}}  to %{{.*}}  step %{{.*}}  -> index {
// CHECK:           %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%arg2 = %17) -> (!fir.array<10xi32>) {
// CHECK-NOT:         %{{.*}} = fir.array_update
// CHECK:             %[[COOR0:.*]] = fir.array_coor %{{.*}}(%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<i32>
// CHECK:             fir.store %{{.*}} to %[[COOR0]] : !fir.ref<i32>
// CHECK-NOT:         fir.array_merge_store

// -----

// Test fir.array_load/boxed array
func.func @conversion_with_temporary_boxed_array(%arr0 : !fir.box<!fir.array<10xi32>>) {
  %c10 = arith.constant 10 : index
  %1:3 = fir.box_dims %arr0, %c10 : (!fir.box<!fir.array<10xi32>>, index) -> (index, index, index)
  %shift = fir.shift %1#0 : (index) -> !fir.shift<1>
  %2 = fir.array_load %arr0(%shift) : (!fir.box<!fir.array<10xi32>>, !fir.shift<1>) -> !fir.array<10xi32>
  %c10_i64 = arith.constant 10 : i64
  %3 = fir.convert %c10_i64 : (i64) -> index
  %c1_i64 = arith.constant 1 : i64
  %c-1_i64 = arith.constant -1 : i64
  %4 = fir.shape %c10 : (index) -> !fir.shape<1>
  %5 = fir.slice %c10_i64, %c1_i64, %c-1_i64 : (i64, i64, i64) -> !fir.slice<1>
  %6 = fir.array_load %arr0(%4) [%5] : (!fir.box<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<10xi32>
  %c1 = arith.constant 1 : index
  %c0 = arith.constant 0 : index
  %7 = arith.subi %3, %c1 : index
  %8 = fir.do_loop %arg0 = %c0 to %7 step %c1 unordered iter_args(%arg1 = %2) -> (!fir.array<10xi32>) {
    %9 = fir.array_fetch %6, %arg0 : (!fir.array<10xi32>, index) -> i32
    %10 = fir.array_update %arg1, %9, %arg0 : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
    fir.result %10 : !fir.array<10xi32>
  }
  fir.array_merge_store %2, %8 to %arr0 : !fir.array<10xi32>, !fir.array<10xi32>, !fir.box<!fir.array<10xi32>>
  return
}

// CHECK-LABEL: func @conversion_with_temporary_boxed_array(
// CHECK-SAME:                                              %[[ARR0:.*]]: !fir.box<!fir.array<10xi32>>)
// Allocation of temporary array.
// CHECK:         %[[TEMP:.*]] = fir.allocmem !fir.array<10xi32>
// Copy of original array to temp.
// CHECK:         fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.box<!fir.array<10xi32>>, !fir.shapeshift<1>, index) -> !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shapeshift<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         }
// Perform the assignment i = i(10:1:-1) using the temporary array.
// CHECK:         %{{.*}} = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} unordered iter_args(%{{.*}} = %{{.*}}) -> (!fir.array<10xi32>) {
// CHECK-NOT:       %{{.*}} = fir.array_fetch
// CHECK-NOT:       %{{.*}} = fir.update
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) [%{{.*}}] %{{.*}} : (!fir.box<!fir.array<10xi32>>, !fir.shape<1>, !fir.slice<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0]] : !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shapeshift<1>, index) -> !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:           fir.result %{{.*}} : !fir.array<10xi32>
// CHECK:         }
// Copy the result back to the original array.
// CHECK:         fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[TEMP]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<10xi32>>, !fir.shapeshift<1>, index) -> !fir.ref<i32>
// CHECK:           %[[COOR1:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.box<!fir.array<10xi32>>, !fir.shapeshift<1>, index) -> !fir.ref<i32>
// CHECK:           %[[LOAD0:.*]] = fir.load %[[COOR0:.*]] : !fir.ref<i32>
// CHECK:           fir.store %[[LOAD0]] to %[[COOR1]] : !fir.ref<i32>
// CHECK:         }
// Free temporary array.
// CHECK:         fir.freemem %[[TEMP]] : !fir.heap<!fir.array<10xi32>>

// -----

// Test simple fir.array_update with Fortran.offsets attribute.
func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
  %c10 = arith.constant 10 : index
  %c20 = arith.constant 20 : index
  %c1 = arith.constant 1 : index
  %f = arith.constant 2.0 : f32
  %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
  %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
  %av2 = fir.array_update %av1, %f, %c1, %c1 {Fortran.offsets} : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
  return
}

// CHECK-LABEL: func @array_update_conversion
// CHECK-NOT:     fir.array_update
// CHECK-NOT:     %{{.*}} = arith.addi %{{.*}}, %{{.*}} : index
// CHECK:         %[[ARRAY_COOR:.*]] = fir.array_coor{{.*}}-> !fir.ref<f32>
// CHECK:         fir.store %{{.*}} to %[[ARRAY_COOR]] : !fir.ref<f32>

// -----

// Test fir.array_fetch on derived type members in an array of derived types.
func.func @array_fetch_derived_type(%0 : !fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>) {
  %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QEi"}
  %c1_i32 = arith.constant 1 : i32
  %2 = fir.convert %c1_i32 : (i32) -> index
  %c10_i32 = arith.constant 10 : i32
  %3 = fir.convert %c10_i32 : (i32) -> index
  %c1 = arith.constant 1 : index
  %shape = fir.shape %2 : (index) -> !fir.shape<1>
  %arr0 = fir.array_load %0(%shape) : (!fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>, !fir.shape<1>) -> !fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>
  %4 = fir.do_loop %arg0 = %2 to %3 step %c1 -> index {
    %6 = fir.convert %arg0 : (index) -> i32
    fir.store %6 to %1 : !fir.ref<i32>
    %c1_i32_0 = arith.constant 1 : i32
    %7 = fir.load %1 : !fir.ref<i32>
    %8 = fir.convert %7 : (i32) -> i64
    %c1_i64 = arith.constant 1 : i64
    %9 = arith.subi %8, %c1_i64 : i64
    %11 = fir.field_index mt, !fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>
    %12 = fir.field_index mem, !fir.type<_QTt{mem:i32}>
    %idx = fir.convert %9 : (i64) -> index
    %res = fir.array_fetch %arr0, %idx, %11, %12 : (!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>, index, !fir.field, !fir.field) -> i32
    %14 = arith.addi %arg0, %c1 : index
    fir.result %14 : index
  }
  %5 = fir.convert %4 : (index) -> i32
  fir.store %5 to %1 : !fir.ref<i32>
  return
}

// CHECK-LABEL: func @array_fetch_derived_type(
// CHECK-SAME:                                 %[[ARR0:.*]]: !fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>) {
// CHECK:         %{{.*}} = fir.do_loop
// CHECK:           %[[FIELD_MT:.*]] = fir.field_index mt, !fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>
// CHECK:           %[[FIELD_MEM:.*]] = fir.field_index mem, !fir.type<_QTt{mem:i32}>
// CHECK-NOT:       %{{.*}} = fir.array_fetch
// CHECK:           %[[COOR0:.*]] = fir.array_coor %[[ARR0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<10x!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>>, !fir.shape<1>, index) -> !fir.ref<!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>
// CHECK:           %[[COOR_OF:.*]] = fir.coordinate_of %[[COOR0]], %[[FIELD_MT]], %[[FIELD_MEM]] : (!fir.ref<!fir.type<_QTu{mt:!fir.type<_QTt{mem:i32}>}>>, !fir.field, !fir.field) -> !fir.ref<i32>
// CHECK:           %{{.*}} = fir.load %[[COOR_OF]] : !fir.ref<i32>

// -----

// Test simple fir.array_load/fir.array_update conversion without copy-in/copy-out with a `fir.box`
func.func @array_update_conversion(%arr1 : !fir.box<!fir.array<?x?xf32>>, %m: index, %n: index) {
  %c10 = arith.constant 10 : index
  %c20 = arith.constant 20 : index
  %c1 = arith.constant 1 : index
  %f = arith.constant 2.0 : f32
  %s = fir.shape %m, %n : (index, index) -> !fir.shape<2>
  %av1 = fir.array_load %arr1(%s) : (!fir.box<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>
  %av2 = fir.array_update %av1, %f, %c1, %c1 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>
  return
}

// -----

// Test array operation with conditional update.

func.func @array_operation_with_cond_update(%arg0: !fir.ref<!fir.array<100xf32>>, %cond1: i1) {
  %c100 = arith.constant 100 : index
  %c1 = arith.constant 1 : index
  %c-1 = arith.constant -1 : index
  %f = arith.constant 2.0 : f32
  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
  %2 = fir.array_load %arg0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
  %arg2 = fir.if %cond1 -> !fir.array<100xf32> {
    fir.result %2 : !fir.array<100xf32>
  } else {
    %r = fir.array_update %2, %f, %c1 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
    fir.result %r : !fir.array<100xf32>
  }
  fir.array_merge_store %2, %arg2 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
  return
}

// CHECK-LABEL: func @array_operation_with_cond_update(
// CHECK-SAME:                                         %[[ARG0:.*]]: !fir.ref<!fir.array<100xf32>>, %[[COND:.*]]: i1) {
// CHECK:         %[[ARRAY_LOAD:.*]] = fir.undefined !fir.array<100xf32>
// CHECK:         %[[IF_RES:.*]] = fir.if %[[COND]] -> (!fir.array<100xf32>) {
// CHECK:           fir.result %[[ARRAY_LOAD]] : !fir.array<100xf32>
// CHECK:         } else {
// CHECK:           %[[UPDATE0:.*]] = fir.array_coor %[[ARG0]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
// CHECK:           fir.store %{{.*}} to %{{.*}} : !fir.ref<f32>
// CHECK:           fir.result %[[ARRAY_LOAD]] : !fir.array<100xf32>
// CHECK:    }