flang/test/HLFIR/order_assignments/forall-codegen-no-conflict.fir

   1 // Test code generation of hlfir.forall, hlfir.forall_index, and hlfir.forall_mask.
   2 // RUN: fir-opt %s --lower-hlfir-ordered-assignments | FileCheck %s
   3
   4 func.func @test_simple(%x: !fir.ref<!fir.array<10xi32>>) {
   5   hlfir.forall lb {
   6     %c1 = arith.constant 1 : index
   7     hlfir.yield %c1 : index
   8   } ub {
   9     %c10 = arith.constant 10 : index
  10     hlfir.yield %c10 : index
  11   }  (%i: index) {
  12     hlfir.region_assign {
  13       %c42 = arith.constant 42 : i32
  14       hlfir.yield %c42 : i32
  15     } to {
  16       %2 = hlfir.designate %x (%i)  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  17       hlfir.yield %2 : !fir.ref<i32>
  18     }
  19   }
  20   return
  21 }
  22 // CHECK-LABEL:   func.func @test_simple(
  23 // CHECK-SAME:                           %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>) {
  24 // CHECK:           %[[VAL_1:.*]] = arith.constant 1 : index
  25 // CHECK:           %[[VAL_2:.*]] = arith.constant 10 : index
  26 // CHECK:           %[[VAL_3:.*]] = arith.constant 1 : index
  27 // CHECK:           %[[VAL_4:.*]] = arith.constant 42 : i32
  28 // CHECK:           fir.do_loop %[[VAL_5:.*]] = %[[VAL_1]] to %[[VAL_2]] step %[[VAL_3]] {
  29 // CHECK:             %[[VAL_6:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_5]])  : (!fir.ref<!fir.array<10xi32>>, index) -> !fir.ref<i32>
  30 // CHECK:             hlfir.assign %[[VAL_4]] to %[[VAL_6]] : i32, !fir.ref<i32>
  31 // CHECK:           }
  32
  33 func.func @test_index(%x: !fir.ref<!fir.array<10xi32>>) {
  34   hlfir.forall lb {
  35     %c1 = arith.constant 1 : index
  36     hlfir.yield %c1 : index
  37   } ub {
  38     %c10 = arith.constant 10 : index
  39     hlfir.yield %c10 : index
  40   }  (%arg1: i32) {
  41     %i = hlfir.forall_index "i" %arg1 : (i32) -> !fir.ref<i32>
  42     hlfir.region_assign {
  43       %i_load = fir.load %i : !fir.ref<i32>
  44       hlfir.yield %i_load : i32
  45     } to {
  46       %2 = hlfir.designate %x (%arg1)  : (!fir.ref<!fir.array<10xi32>>, i32) -> !fir.ref<i32>
  47       hlfir.yield %2 : !fir.ref<i32>
  48     }
  49   }
  50   return
  51 }
  52 // CHECK-LABEL:   func.func @test_index(
  53 // CHECK-SAME:                          %[[VAL_0:.*]]: !fir.ref<!fir.array<10xi32>>) {
  54 // CHECK:           %[[VAL_1:.*]] = fir.alloca i32 {bindc_name = "i"}
  55 // CHECK:           %[[VAL_2:.*]] = arith.constant 1 : index
  56 // CHECK:           %[[VAL_3:.*]] = arith.constant 10 : index
  57 // CHECK:           %[[VAL_4:.*]] = arith.constant 1 : index
  58 // CHECK:           fir.do_loop %[[VAL_5:.*]] = %[[VAL_2]] to %[[VAL_3]] step %[[VAL_4]] {
  59 // CHECK:             %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (index) -> i32
  60 // CHECK:             fir.store %[[VAL_6]] to %[[VAL_1]] : !fir.ref<i32>
  61 // CHECK:             %[[VAL_7:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
  62 // CHECK:             %[[VAL_8:.*]] = hlfir.designate %[[VAL_0]] (%[[VAL_6]])  : (!fir.ref<!fir.array<10xi32>>, i32) -> !fir.ref<i32>
  63 // CHECK:             hlfir.assign %[[VAL_7]] to %[[VAL_8]] : i32, !fir.ref<i32>
  64 // CHECK:           }
  65
  66
  67 func.func @split_schedule(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.box<!fir.array<?xf32>>, %arg2: !fir.box<!fir.array<?x?xf32>>) {
  68   %c11 = arith.constant 11 : i64
  69   %c10 = arith.constant 10 : i64
  70   %c1 = arith.constant 1 : i64
  71   %0:2 = hlfir.declare %arg0 {uniq_name = "x"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
  72   %1:2 = hlfir.declare %arg1 {uniq_name = "y"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
  73   %2:2 = hlfir.declare %arg2 {uniq_name = "z"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
  74   hlfir.forall lb {
  75     hlfir.yield %c1 : i64
  76   } ub {
  77     hlfir.yield %c10 : i64
  78   }  (%arg3: i64) {
  79     hlfir.region_assign {
  80       %3 = hlfir.designate %1#0 (%arg3)  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
  81       %4 = fir.load %3 : !fir.ref<f32>
  82       hlfir.yield %4 : f32
  83     } to {
  84       %3 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
  85       hlfir.yield %3 : !fir.ref<f32>
  86     }
  87     hlfir.forall lb {
  88       hlfir.yield %c1 : i64
  89     } ub {
  90       hlfir.yield %c10 : i64
  91     }  (%arg4: i64) {
  92       hlfir.region_assign {
  93         %3 = arith.subi %c11, %arg3 : i64
  94         %4 = hlfir.designate %0#0 (%3)  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
  95         %5 = fir.load %4 : !fir.ref<f32>
  96         hlfir.yield %5 : f32
  97       } to {
  98         %3 = hlfir.designate %2#0 (%arg3, %arg4)  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
  99         hlfir.yield %3 : !fir.ref<f32>
 100       }
 101     }
 102   }
 103   return
 104 }
 105 // CHECK-LABEL:   func.func @split_schedule(
 106 // CHECK:           %[[VAL_3:.*]] = arith.constant 11 : i64
 107 // CHECK:           %[[VAL_4:.*]] = arith.constant 10 : i64
 108 // CHECK:           %[[VAL_5:.*]] = arith.constant 1 : i64
 109 // CHECK:           %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "x"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
 110 // CHECK:           %[[VAL_7:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "y"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
 111 // CHECK:           %[[VAL_8:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "z"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
 112 // CHECK:           %[[VAL_9:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
 113 // CHECK:           %[[VAL_10:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
 114 // CHECK:           %[[VAL_11:.*]] = arith.constant 1 : index
 115 // CHECK:           fir.do_loop %[[VAL_12:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_11]] {
 116 // CHECK:             %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (index) -> i64
 117 // CHECK:             %[[VAL_14:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_13]])  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
 118 // CHECK:             %[[VAL_15:.*]] = fir.load %[[VAL_14]] : !fir.ref<f32>
 119 // CHECK:             %[[VAL_16:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_13]])  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
 120 // CHECK:             hlfir.assign %[[VAL_15]] to %[[VAL_16]] : f32, !fir.ref<f32>
 121 // CHECK:           }
 122 // CHECK:           %[[VAL_17:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
 123 // CHECK:           %[[VAL_18:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
 124 // CHECK:           %[[VAL_19:.*]] = arith.constant 1 : index
 125 // CHECK:           %[[VAL_22:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
 126 // CHECK:           %[[VAL_23:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
 127 // CHECK:           %[[VAL_24:.*]] = arith.constant 1 : index
 128 // CHECK:           fir.do_loop %[[VAL_20:.*]] = %[[VAL_17]] to %[[VAL_18]] step %[[VAL_19]] {
 129 // CHECK:             %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (index) -> i64
 130 // CHECK:             fir.do_loop %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_23]] step %[[VAL_24]] {
 131 // CHECK:               %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (index) -> i64
 132 // CHECK:               %[[VAL_27:.*]] = arith.subi %[[VAL_3]], %[[VAL_21]] : i64
 133 // CHECK:               %[[VAL_28:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_27]])  : (!fir.box<!fir.array<?xf32>>, i64) -> !fir.ref<f32>
 134 // CHECK:               %[[VAL_29:.*]] = fir.load %[[VAL_28]] : !fir.ref<f32>
 135 // CHECK:               %[[VAL_30:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_21]], %[[VAL_26]])  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
 136 // CHECK:               hlfir.assign %[[VAL_29]] to %[[VAL_30]] : f32, !fir.ref<f32>
 137 // CHECK:             }
 138 // CHECK:           }
 139
 140 func.func @test_mask(%arg0: !fir.box<!fir.array<?x?xf32>>, %arg1: !fir.box<!fir.array<?x?xf32>>, %arg2: !fir.box<!fir.array<?x!fir.logical<4>>>) {
 141   %c10 = arith.constant 10 : i64
 142   %c1 = arith.constant 1 : i64
 143   %0:2 = hlfir.declare %arg2 {uniq_name = "mask"} : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> (!fir.box<!fir.array<?x!fir.logical<4>>>, !fir.box<!fir.array<?x!fir.logical<4>>>)
 144   %1:2 = hlfir.declare %arg0 {uniq_name = "x"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
 145   %2:2 = hlfir.declare %arg1 {uniq_name = "y"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
 146   hlfir.forall lb {
 147     hlfir.yield %c1 : i64
 148   } ub {
 149     hlfir.yield %c10 : i64
 150   }  (%arg3: i64) {
 151     hlfir.forall_mask {
 152       %3 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?x!fir.logical<4>>>, i64) -> !fir.ref<!fir.logical<4>>
 153       %4 = fir.load %3 : !fir.ref<!fir.logical<4>>
 154       %5 = fir.convert %4 : (!fir.logical<4>) -> i1
 155       hlfir.yield %5 : i1
 156     } do {
 157       hlfir.forall lb {
 158         hlfir.yield %c1 : i64
 159       } ub {
 160         hlfir.yield %arg3 : i64
 161       }  (%arg4: i64) {
 162         hlfir.region_assign {
 163           %3 = hlfir.designate %2#0 (%arg3, %arg4)  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
 164           %4 = fir.load %3 : !fir.ref<f32>
 165           hlfir.yield %4 : f32
 166         } to {
 167           %3 = hlfir.designate %1#0 (%arg3, %arg4)  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
 168           hlfir.yield %3 : !fir.ref<f32>
 169         }
 170       }
 171     }
 172   }
 173   return
 174 }
 175 // CHECK-LABEL:   func.func @test_mask(
 176 // CHECK:           %[[VAL_3:.*]] = arith.constant 10 : i64
 177 // CHECK:           %[[VAL_4:.*]] = arith.constant 1 : i64
 178 // CHECK:           %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "mask"} : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> (!fir.box<!fir.array<?x!fir.logical<4>>>, !fir.box<!fir.array<?x!fir.logical<4>>>)
 179 // CHECK:           %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "x"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
 180 // CHECK:           %[[VAL_7:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "y"} : (!fir.box<!fir.array<?x?xf32>>) -> (!fir.box<!fir.array<?x?xf32>>, !fir.box<!fir.array<?x?xf32>>)
 181 // CHECK:           %[[VAL_8:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
 182 // CHECK:           %[[VAL_9:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
 183 // CHECK:           %[[VAL_10:.*]] = arith.constant 1 : index
 184 // CHECK:           %[[VAL_16:.*]] = fir.convert %[[VAL_4]] : (i64) -> index
 185 // CHECK:           %[[VAL_18:.*]] = arith.constant 1 : index
 186 // CHECK:           fir.do_loop %[[VAL_11:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_10]] {
 187 // CHECK:             %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (index) -> i64
 188 // CHECK:             %[[VAL_13:.*]] = hlfir.designate %[[VAL_5]]#0 (%[[VAL_12]])  : (!fir.box<!fir.array<?x!fir.logical<4>>>, i64) -> !fir.ref<!fir.logical<4>>
 189 // CHECK:             %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref<!fir.logical<4>>
 190 // CHECK:             %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (!fir.logical<4>) -> i1
 191 // CHECK:             fir.if %[[VAL_15]] {
 192 // CHECK:               %[[VAL_17:.*]] = fir.convert %[[VAL_12]] : (i64) -> index
 193 // CHECK:               fir.do_loop %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_18]] {
 194 // CHECK:                 %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (index) -> i64
 195 // CHECK:                 %[[VAL_21:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_12]], %[[VAL_20]])  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
 196 // CHECK:                 %[[VAL_22:.*]] = fir.load %[[VAL_21]] : !fir.ref<f32>
 197 // CHECK:                 %[[VAL_23:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_12]], %[[VAL_20]])  : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
 198 // CHECK:                 hlfir.assign %[[VAL_22]] to %[[VAL_23]] : f32, !fir.ref<f32>
 199 // CHECK:               }
 200 // CHECK:             }
 201 // CHECK:           }