flang/test/HLFIR/order_assignments/user-defined-assignment.fir

   1 // Test code generation of hlfir.region_assign with user defined
   2 // assignment.
   3 // RUN: fir-opt %s --lower-hlfir-ordered-assignments | FileCheck %s
   4
   5 func.func @test_simple_scalar(%i: !fir.ref<i32>, %l: !fir.ref<!fir.logical<4>>) {
   6   hlfir.region_assign {
   7     hlfir.yield %l : !fir.ref<!fir.logical<4>>
   8   } to {
   9     hlfir.yield %i : !fir.ref<i32>
  10   } user_defined_assign (%arg0: !fir.ref<!fir.logical<4>>) to (%arg1: !fir.ref<i32>) {
  11     fir.call @logical_to_numeric(%arg1, %arg0) : (!fir.ref<i32>, !fir.ref<!fir.logical<4>>) -> ()
  12   }
  13   return
  14 }
  15 // CHECK-LABEL:   func.func @test_simple_scalar(
  16 // CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<i32>,
  17 // CHECK-SAME:    %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>>) {
  18 // CHECK:  %[[VAL_2:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.logical<4>>
  19 // CHECK:  %[[VAL_3:.*]]:3 = hlfir.associate %[[VAL_2]] {uniq_name = ".tmp.assign"} : (!fir.logical<4>) -> (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<4>>, i1)
  20 // CHECK:  fir.call @logical_to_numeric(%[[VAL_0]], %[[VAL_3]]#0) : (!fir.ref<i32>, !fir.ref<!fir.logical<4>>) -> ()
  21 // CHECK:  hlfir.end_associate %[[VAL_3]]#1, %[[VAL_3]]#2 : !fir.ref<!fir.logical<4>>, i1
  22
  23 func.func @test_elemental_overlap(%i: !fir.ref<!fir.array<10xi32>>) {
  24   %c0_i32 = arith.constant 0 : i32
  25   %c10 = arith.constant 10 : index
  26   %shape  = fir.shape %c10 : (index) -> !fir.shape<1>
  27   hlfir.region_assign {
  28     %cmp = hlfir.elemental %shape : (!fir.shape<1>) -> !hlfir.expr<10x!fir.logical<4>> {
  29     ^bb0(%j: index):
  30       %ielt = hlfir.designate %i (%j)  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  31       %ielt_val = fir.load %ielt : !fir.ref<i32>
  32       %smaller = arith.cmpi slt, %ielt_val, %c0_i32 : i32
  33       %smaller_cast = fir.convert %smaller : (i1) -> !fir.logical<4>
  34       hlfir.yield_element %smaller_cast : !fir.logical<4>
  35     }
  36     hlfir.yield %cmp : !hlfir.expr<10x!fir.logical<4>>
  37   } to {
  38     hlfir.yield %i : !fir.ref<!fir.array<10xi32>>
  39   } user_defined_assign (%arg0: !fir.logical<4>) to (%arg1: !fir.ref<i32>) {
  40     fir.call @logical_value_to_numeric(%arg1, %arg0) : (!fir.ref<i32>, !fir.logical<4>) -> ()
  41   }
  42   return
  43 }
  44 // CHECK-LABEL:   func.func @test_elemental_overlap(
  45 // CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>) {
  46 // CHECK:  %[[VAL_1:.*]] = arith.constant 0 : i32
  47 // CHECK:  %[[VAL_2:.*]] = arith.constant 10 : index
  48 // CHECK:  %[[VAL_3:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
  49 // CHECK:  %[[VAL_4:.*]] = hlfir.elemental %[[VAL_3]] : (!fir.shape<1>) -> !hlfir.expr<10x!fir.logical<4>> {
  50 // CHECK:  ^bb0(%[[VAL_5:.*]]: index):
  51 // CHECK:    %[[VAL_6:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_5]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  52 // CHECK:    %[[VAL_7:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
  53 // CHECK:    %[[VAL_8:.*]] = arith.cmpi slt, %[[VAL_7]], %[[VAL_1]] : i32
  54 // CHECK:    %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i1) -> !fir.logical<4>
  55 // CHECK:    hlfir.yield_element %[[VAL_9]] : !fir.logical<4>
  56 // CHECK:  }
  57 // CHECK:  %[[VAL_10:.*]]:3 = hlfir.associate %[[VAL_11:.*]](%[[VAL_3]]) {uniq_name = ".tmp.assign"} : (!hlfir.expr<10x!fir.logical<4>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.ref<!fir.array<10x!fir.logical<4>>>, i1)
  58 // CHECK:  %[[VAL_12:.*]] = arith.constant 10 : index
  59 // CHECK:  %[[VAL_13:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1>
  60 // CHECK:  %[[VAL_14:.*]] = arith.constant 1 : index
  61 // CHECK:  fir.do_loop %[[VAL_15:.*]] = %[[VAL_14]] to %[[VAL_12]] step %[[VAL_14]] {
  62 // CHECK:    %[[VAL_16:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_15]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  63 // CHECK:    %[[VAL_17:.*]] = hlfir.designate %[[VAL_10]]#0 (%[[VAL_15]])  : (!fir.ref<!fir.array<10x!fir.logical<4>>>, index) -> !fir.ref<!fir.logical<4>>
  64 // CHECK:    %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref<!fir.logical<4>>
  65 // CHECK:    fir.call @logical_value_to_numeric(%[[VAL_16]], %[[VAL_18]]) : (!fir.ref<i32>, !fir.logical<4>) -> ()
  66 // CHECK:  }
  67 // CHECK:  hlfir.end_associate %[[VAL_10]]#1, %[[VAL_10]]#2 : !fir.ref<!fir.array<10x!fir.logical<4>>>, i1
  68
  69 func.func @test_array_overlap(%i: !fir.ref<!fir.array<10xi32>>) {
  70   %c0_i32 = arith.constant 0 : i32
  71   %c10 = arith.constant 10 : index
  72   %shape  = fir.shape %c10 : (index) -> !fir.shape<1>
  73   hlfir.region_assign {
  74     %cmp = hlfir.elemental %shape : (!fir.shape<1>) -> !hlfir.expr<10x!fir.logical<4>> {
  75     ^bb0(%j: index):
  76       %ielt = hlfir.designate %i (%j)  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  77       %ielt_val = fir.load %ielt : !fir.ref<i32>
  78       %smaller = arith.cmpi slt, %ielt_val, %c0_i32 : i32
  79       %smaller_cast = fir.convert %smaller : (i1) -> !fir.logical<4>
  80       hlfir.yield_element %smaller_cast : !fir.logical<4>
  81     }
  82     hlfir.yield %cmp : !hlfir.expr<10x!fir.logical<4>>
  83   } to {
  84     hlfir.yield %i : !fir.ref<!fir.array<10xi32>>
  85   } user_defined_assign (%arg0: !hlfir.expr<10x!fir.logical<4>>) to (%arg1: !fir.ref<!fir.array<10xi32>>) {
  86      %1:3 = hlfir.associate %arg0(%shape) {uniq_name = "adapt.valuebyref"} : (!hlfir.expr<10x!fir.logical<4>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.ref<!fir.array<10x!fir.logical<4>>>, i1)
  87     fir.call @logical_array_to_numeric(%arg1, %1#0) : (!fir.ref<!fir.array<10xi32>>, !fir.ref<!fir.array<10x!fir.logical<4>>>) -> ()
  88      hlfir.end_associate %1#1, %1#2 : !fir.ref<!fir.array<10x!fir.logical<4>>>, i1
  89   }
  90   return
  91 }
  92 // CHECK-LABEL:   func.func @test_array_overlap(
  93 // CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>) {
  94 // CHECK:  %[[VAL_1:.*]] = arith.constant 0 : i32
  95 // CHECK:  %[[VAL_2:.*]] = arith.constant 10 : index
  96 // CHECK:  %[[VAL_3:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
  97 // CHECK:  %[[VAL_4:.*]] = hlfir.elemental %[[VAL_3]] : (!fir.shape<1>) -> !hlfir.expr<10x!fir.logical<4>> {
  98 // CHECK:  ^bb0(%[[VAL_5:.*]]: index):
  99 // CHECK:    %[[VAL_6:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_5]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
 100 // CHECK:    %[[VAL_7:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
 101 // CHECK:    %[[VAL_8:.*]] = arith.cmpi slt, %[[VAL_7]], %[[VAL_1]] : i32
 102 // CHECK:    %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i1) -> !fir.logical<4>
 103 // CHECK:    hlfir.yield_element %[[VAL_9]] : !fir.logical<4>
 104 // CHECK:  }
 105 // CHECK:  %[[VAL_10:.*]]:3 = hlfir.associate %[[VAL_11:.*]](%[[VAL_3]]) {uniq_name = ".tmp.assign"} : (!hlfir.expr<10x!fir.logical<4>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.ref<!fir.array<10x!fir.logical<4>>>, i1)
 106 // CHECK:  %[[VAL_12:.*]] = hlfir.as_expr %[[VAL_10]]#0 : (!fir.ref<!fir.array<10x!fir.logical<4>>>) -> !hlfir.expr<10x!fir.logical<4>>
 107 // CHECK:  %[[VAL_13:.*]]:3 = hlfir.associate %[[VAL_12]](%[[VAL_3]]) {uniq_name = "adapt.valuebyref"} : (!hlfir.expr<10x!fir.logical<4>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10x!fir.logical<4>>>, !fir.ref<!fir.array<10x!fir.logical<4>>>, i1)
 108 // CHECK:  fir.call @logical_array_to_numeric(%[[VAL_0]], %[[VAL_13]]#0) : (!fir.ref<!fir.array<10xi32>>, !fir.ref<!fir.array<10x!fir.logical<4>>>) -> ()
 109 // CHECK:  hlfir.end_associate %[[VAL_13]]#1, %[[VAL_13]]#2 : !fir.ref<!fir.array<10x!fir.logical<4>>>, i1
 110 // CHECK:  hlfir.destroy %[[VAL_12]] : !hlfir.expr<10x!fir.logical<4>>
 111 // CHECK:  hlfir.end_associate %[[VAL_10]]#1, %[[VAL_10]]#2 : !fir.ref<!fir.array<10x!fir.logical<4>>>, i1
 112
 113 func.func @test_scalar_forall_overlap(%i: !fir.ref<!fir.array<10xi32>>) {
 114   %c0_i32 = arith.constant 0 : i32
 115   %c1 = arith.constant 1 : index
 116   %c10 = arith.constant 10 : index
 117   %c11 = arith.constant 11 : index
 118   hlfir.forall lb {
 119     hlfir.yield %c1 : index
 120   } ub {
 121     hlfir.yield %c10 : index
 122   }  (%j: index) {
 123     hlfir.region_assign {
 124       %reverse_j = arith.subi %c11, %j : index
 125       %ielt = hlfir.designate %i (%reverse_j)  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
 126       %ielt_val = fir.load %ielt : !fir.ref<i32>
 127       %smaller = arith.cmpi slt, %ielt_val, %c0_i32 : i32
 128       hlfir.yield %smaller : i1
 129     } to {
 130       %ielt = hlfir.designate %i (%j)  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
 131       hlfir.yield %ielt : !fir.ref<i32>
 132     } user_defined_assign (%arg0: i1) to (%arg1: !fir.ref<i32>) {
 133       %cast = fir.convert %arg0 : (i1) -> !fir.logical<4>
 134       fir.call @logical_value_to_numeric(%arg1, %cast) : (!fir.ref<i32>, !fir.logical<4>) -> ()
 135     }
 136   }
 137   return
 138 }
 139 // CHECK-LABEL:   func.func @test_scalar_forall_overlap(
 140 // CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>) {
 141 // CHECK:  %[[VAL_1:.*]] = fir.alloca index
 142 // CHECK:  %[[VAL_2:.*]] = arith.constant 0 : i32
 143 // CHECK:  %[[VAL_3:.*]] = arith.constant 1 : index
 144 // CHECK:  %[[VAL_4:.*]] = arith.constant 10 : index
 145 // CHECK:  %[[VAL_5:.*]] = arith.constant 11 : index
 146 // CHECK:  %[[VAL_6:.*]] = arith.constant 1 : index
 147 // CHECK:  %[[VAL_7:.*]] = arith.constant 0 : index
 148 // CHECK:  %[[VAL_8:.*]] = arith.subi %[[VAL_4]], %[[VAL_3]] : index
 149 // CHECK:  %[[VAL_9:.*]] = arith.addi %[[VAL_8]], %[[VAL_6]] : index
 150 // CHECK:  %[[VAL_10:.*]] = arith.divsi %[[VAL_9]], %[[VAL_6]] : index
 151 // CHECK:  %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_10]], %[[VAL_7]] : index
 152 // CHECK:  %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_10]], %[[VAL_7]] : index
 153 // CHECK:  %[[VAL_13:.*]] = arith.constant 1 : index
 154 // CHECK:  %[[VAL_14:.*]] = arith.constant 1 : index
 155 // CHECK:  fir.store %[[VAL_13]] to %[[VAL_1]] : !fir.ref<index>
 156 // CHECK:  %[[VAL_15:.*]] = fir.allocmem !fir.array<?xi1>, %[[VAL_12]] {bindc_name = ".tmp.forall", uniq_name = ""}
 157 // CHECK:  %[[VAL_16:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1>
 158 // CHECK:  %[[VAL_17:.*]]:2 = hlfir.declare %[[VAL_15]](%[[VAL_16]]) {uniq_name = ".tmp.forall"} : (!fir.heap<!fir.array<?xi1>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi1>>, !fir.heap<!fir.array<?xi1>>)
 159 // CHECK:  fir.do_loop %[[VAL_18:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_6]] {
 160 // CHECK:    %[[VAL_19:.*]] = arith.subi %[[VAL_5]], %[[VAL_18]] : index
 161 // CHECK:    %[[VAL_20:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_19]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
 162 // CHECK:    %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref<i32>
 163 // CHECK:    %[[VAL_22:.*]] = arith.cmpi slt, %[[VAL_21]], %[[VAL_2]] : i32
 164 // CHECK:    %[[VAL_23:.*]] = fir.load %[[VAL_1]] : !fir.ref<index>
 165 // CHECK:    %[[VAL_24:.*]] = arith.addi %[[VAL_23]], %[[VAL_14]] : index
 166 // CHECK:    fir.store %[[VAL_24]] to %[[VAL_1]] : !fir.ref<index>
 167 // CHECK:    %[[VAL_25:.*]] = hlfir.designate %[[VAL_17]]#0 (%[[VAL_23]])  : (!fir.box<!fir.array<?xi1>>, index) -> !fir.ref<i1>
 168 // CHECK:    hlfir.assign %[[VAL_22]] to %[[VAL_25]] : i1, !fir.ref<i1>
 169 // CHECK:  }
 170 // CHECK:  %[[VAL_26:.*]] = arith.constant 1 : index
 171 // CHECK:  fir.store %[[VAL_13]] to %[[VAL_1]] : !fir.ref<index>
 172 // CHECK:  fir.do_loop %[[VAL_27:.*]] = %[[VAL_3]] to %[[VAL_4]] step %[[VAL_26]] {
 173 // CHECK:    %[[VAL_28:.*]] = fir.load %[[VAL_1]] : !fir.ref<index>
 174 // CHECK:    %[[VAL_29:.*]] = arith.addi %[[VAL_28]], %[[VAL_14]] : index
 175 // CHECK:    fir.store %[[VAL_29]] to %[[VAL_1]] : !fir.ref<index>
 176 // CHECK:    %[[VAL_30:.*]] = hlfir.designate %[[VAL_17]]#0 (%[[VAL_28]])  : (!fir.box<!fir.array<?xi1>>, index) -> !fir.ref<i1>
 177 // CHECK:    %[[VAL_31:.*]] = fir.load %[[VAL_30]] : !fir.ref<i1>
 178 // CHECK:    %[[VAL_32:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_27]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
 179 // CHECK:    %[[VAL_33:.*]] = fir.convert %[[VAL_31]] : (i1) -> !fir.logical<4>
 180 // CHECK:    fir.call @logical_value_to_numeric(%[[VAL_32]], %[[VAL_33]]) : (!fir.ref<i32>, !fir.logical<4>) -> ()
 181 // CHECK:  }
 182 // CHECK:  fir.freemem %[[VAL_15]] : !fir.heap<!fir.array<?xi1>>
 183
 184 func.func @test_saved_scalar_box(%arg0: !fir.box<!fir.type<sometype>>, %arg1: !fir.class<!fir.type<sometype>>) {
 185   hlfir.region_assign {
 186     hlfir.yield %arg0 : !fir.box<!fir.type<sometype>>
 187   } to {
 188     hlfir.yield %arg1 : !fir.class<!fir.type<sometype>>
 189   } user_defined_assign  (%arg2: !fir.box<!fir.type<sometype>>) to (%arg3: !fir.class<!fir.type<sometype>>) {
 190     fir.call @user_assign_box(%arg3, %arg2) : (!fir.class<!fir.type<sometype>>, !fir.box<!fir.type<sometype>>) -> ()
 191   }
 192   return
 193 }
 194 func.func private @user_assign_box(!fir.class<!fir.type<sometype>>, !fir.box<!fir.type<sometype>>) -> ()
 195
 196 // CHECK-LABEL:   func.func @test_saved_scalar_box(
 197 // CHECK-SAME:                    %[[VAL_0:.*]]: !fir.box<!fir.type<sometype>>,
 198 // CHECK-SAME:                    %[[VAL_1:.*]]: !fir.class<!fir.type<sometype>>) {
 199 // CHECK:           %[[VAL_2:.*]] = hlfir.as_expr %[[VAL_0]] : (!fir.box<!fir.type<sometype>>) -> !hlfir.expr<!fir.type<sometype>>
 200 // CHECK:           %[[VAL_3:.*]]:3 = hlfir.associate %[[VAL_2]]
 201 // CHECK:           %[[VAL_4:.*]] = fir.embox %[[VAL_3]]#1 : (!fir.ref<!fir.type<sometype>>) -> !fir.box<!fir.type<sometype>>
 202 // CHECK:           fir.call @user_assign_box(%[[VAL_1]], %[[VAL_4]]) : (!fir.class<!fir.type<sometype>>, !fir.box<!fir.type<sometype>>) -> ()
 203 // CHECK:           hlfir.end_associate %[[VAL_3]]#1, %[[VAL_3]]#2 : !fir.ref<!fir.type<sometype>>, i1
 204 // CHECK:           return
 205 // CHECK:         }