flang/test/HLFIR/minloc-elemental.fir

   1 // RUN: fir-opt %s -opt-bufferization | FileCheck %s
   2
   3 func.func @_QPtest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "m"}) {
   4   %c0 = arith.constant 0 : index
   5   %0:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
   6   %1:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
   7   %2:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
   8   %3 = fir.load %2#0 : !fir.ref<i32>
   9   %4:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  10   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
  11   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
  12   ^bb0(%arg3: index):
  13     %8 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  14     %9 = fir.load %8 : !fir.ref<i32>
  15     %10 = arith.cmpi sge, %9, %3 : i32
  16     %11 = fir.convert %10 : (i1) -> !fir.logical<4>
  17     hlfir.yield_element %11 : !fir.logical<4>
  18   }
  19   %7 = hlfir.minloc %0#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi32>
  20   hlfir.assign %7 to %1#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>
  21   hlfir.destroy %7 : !hlfir.expr<1xi32>
  22   hlfir.destroy %6 : !hlfir.expr<?x!fir.logical<4>>
  23   return
  24 }
  25 // CHECK-LABEL: func.func @_QPtest(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "m"}) {
  26 // CHECK-NEXT:    %true = arith.constant true
  27 // CHECK-NEXT:    %c2147483647_i32 = arith.constant 2147483647 : i32
  28 // CHECK-NEXT:    %c1_i32 = arith.constant 1 : i32
  29 // CHECK-NEXT:    %c0 = arith.constant 0 : index
  30 // CHECK-NEXT:    %c1 = arith.constant 1 : index
  31 // CHECK-NEXT:    %c0_i32 = arith.constant 0 : i32
  32 // CHECK-NEXT:    %[[V0:.*]] = fir.alloca i32
  33 // CHECK-NEXT:    %[[RES:.*]] = fir.alloca !fir.array<1xi32>
  34 // CHECK-NEXT:    %[[V1:.*]]:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  35 // CHECK-NEXT:    %[[V2:.*]]:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  36 // CHECK-NEXT:    %[[V3:.*]]:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
  37 // CHECK-NEXT:    %[[V4:.*]] = fir.load %[[V3]]#0 : !fir.ref<i32>
  38 // CHECK-NEXT:    %[[V8:.*]] = hlfir.designate %[[RES]] (%c1) : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
  39 // CHECK-NEXT:    fir.store %c0_i32 to %[[V8]] : !fir.ref<i32>
  40 // CHECK-NEXT:    fir.store %c0_i32 to %[[V0]] : !fir.ref<i32>
  41 // CHECK-NEXT:    %[[V9:.*]]:3 = fir.box_dims %[[V1]]#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  42 // CHECK-NEXT:    %[[V10:.*]] = arith.subi %[[V9]]#1, %c1 : index
  43 // CHECK-NEXT:    %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) {
  44 // CHECK-NEXT:      %[[V14:.*]] = arith.addi %arg3, %c1 : index
  45 // CHECK-NEXT:      %[[V15:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  46 // CHECK-NEXT:      %[[V16:.*]] = fir.load %[[V15]] : !fir.ref<i32>
  47 // CHECK-NEXT:      %[[V17:.*]] = arith.cmpi sge, %[[V16]], %[[V4]] : i32
  48 // CHECK-NEXT:      %[[V18:.*]] = fir.if %[[V17]] -> (i32) {
  49 // CHECK-NEXT:        %[[ISFIRST:.*]] = fir.load %[[V0]] : !fir.ref<i32>
  50 // CHECK-NEXT:        %[[V19:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  51 // CHECK-NEXT:        %[[V20:.*]] = fir.load %[[V19]] : !fir.ref<i32>
  52 // CHECK-NEXT:        %[[V21:.*]] = arith.cmpi slt, %[[V20]], %arg4 : i32
  53 // CHECK-NEXT:        %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
  54 // CHECK-NEXT:        %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
  55 // CHECK-NEXT:        %[[ORCOND:.*]] = arith.ori %[[V21]], %[[ISFIRSTNOT]] : i1
  56 // CHECK-NEXT:        %[[V22:.*]] = fir.if %[[ORCOND]] -> (i32) {
  57 // CHECK-NEXT:          fir.store %c1_i32 to %[[V0]] : !fir.ref<i32>
  58 // CHECK-NEXT:          %[[V23:.*]] = hlfir.designate %[[RES]] (%c1) : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
  59 // CHECK-NEXT:          %[[V24:.*]] = fir.convert %[[V14]] : (index) -> i32
  60 // CHECK-NEXT:          fir.store %[[V24]] to %[[V23]] : !fir.ref<i32>
  61 // CHECK-NEXT:          fir.result %[[V20]] : i32
  62 // CHECK-NEXT:        } else {
  63 // CHECK-NEXT:          fir.result %arg4 : i32
  64 // CHECK-NEXT:        }
  65 // CHECK-NEXT:        fir.result %[[V22]] : i32
  66 // CHECK-NEXT:      } else {
  67 // CHECK-NEXT:        fir.result %arg4 : i32
  68 // CHECK-NEXT:      }
  69 // CHECK-NEXT:      fir.result %[[V18]] : i32
  70 // CHECK-NEXT:    }
  71 // CHECK-NEXT:    %[[BD:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  72 // CHECK-NEXT:    fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered {
  73 // CHECK-NEXT:      %[[V13:.*]] = hlfir.designate %[[RES]] (%arg3)  : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
  74 // CHECK-NEXT:      %[[V14:.*]] = fir.load %[[V13]] : !fir.ref<i32>
  75 // CHECK-NEXT:      %[[V15:.*]] = hlfir.designate %[[V2]]#0 (%arg3)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  76 // CHECK-NEXT:      hlfir.assign %[[V14]] to %[[V15]] : i32, !fir.ref<i32>
  77 // CHECK-NEXT:    }
  78 // CHECK-NEXT:    return
  79 // CHECK-NEXT:  }
  80
  81
  82 func.func @_QPtest_kind2(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "m"}) {
  83   %c0 = arith.constant 0 : index
  84   %0:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  85   %1:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi16>>) -> (!fir.box<!fir.array<?xi16>>, !fir.box<!fir.array<?xi16>>)
  86   %2:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
  87   %3 = fir.load %2#0 : !fir.ref<i32>
  88   %4:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  89   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
  90   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
  91   ^bb0(%arg3: index):
  92     %8 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  93     %9 = fir.load %8 : !fir.ref<i32>
  94     %10 = arith.cmpi sge, %9, %3 : i32
  95     %11 = fir.convert %10 : (i1) -> !fir.logical<4>
  96     hlfir.yield_element %11 : !fir.logical<4>
  97   }
  98   %7 = hlfir.minloc %0#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi16>
  99   hlfir.assign %7 to %1#0 : !hlfir.expr<1xi16>, !fir.box<!fir.array<?xi16>>
 100   hlfir.destroy %7 : !hlfir.expr<1xi16>
 101   hlfir.destroy %6 : !hlfir.expr<?x!fir.logical<4>>
 102   return
 103 }
 104 // CHECK-LABEL:  func.func @_QPtest_kind2(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi16>> {fir.bindc_name = "m"}) {
 105 // CHECK-NEXT:    %true = arith.constant true
 106 // CHECK-NEXT:    %c2147483647_i32 = arith.constant 2147483647 : i32
 107 // CHECK-NEXT:    %c1_i16 = arith.constant 1 : i16
 108 // CHECK-NEXT:    %c0 = arith.constant 0 : index
 109 // CHECK-NEXT:    %c1 = arith.constant 1 : index
 110 // CHECK-NEXT:    %c0_i16 = arith.constant 0 : i16
 111 // CHECK-NEXT:    %[[V0:.*]] = fir.alloca i16
 112 // CHECK-NEXT:    %[[RES:.*]] = fir.alloca !fir.array<1xi16>
 113 // CHECK-NEXT:    %[[V1:.*]]:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 114 // CHECK-NEXT:    %[[V2:.*]]:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi16>>) -> (!fir.box<!fir.array<?xi16>>, !fir.box<!fir.array<?xi16>>)
 115 // CHECK-NEXT:    %[[V3:.*]]:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 116 // CHECK-NEXT:    %[[V4:.*]] = fir.load %[[V3]]#0 : !fir.ref<i32>
 117 // CHECK-NEXT:    %[[V8:.*]] = hlfir.designate %[[RES]] (%c1) : (!fir.ref<!fir.array<1xi16>>, index) -> !fir.ref<i16>
 118 // CHECK-NEXT:    fir.store %c0_i16 to %[[V8]] : !fir.ref<i16>
 119 // CHECK-NEXT:    fir.store %c0_i16 to %[[V0]] : !fir.ref<i16>
 120 // CHECK-NEXT:    %[[V9:.*]]:3 = fir.box_dims %[[V1]]#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 121 // CHECK-NEXT:    %[[V10:.*]] = arith.subi %[[V9]]#1, %c1 : index
 122 // CHECK-NEXT:    %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) {
 123 // CHECK-NEXT:      %[[V14:.*]] = arith.addi %arg3, %c1 : index
 124 // CHECK-NEXT:      %[[V15:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 125 // CHECK-NEXT:      %[[V16:.*]] = fir.load %[[V15]] : !fir.ref<i32>
 126 // CHECK-NEXT:      %[[V17:.*]] = arith.cmpi sge, %[[V16]], %[[V4]] : i32
 127 // CHECK-NEXT:      %[[V18:.*]] = fir.if %[[V17]] -> (i32) {
 128 // CHECK-NEXT:        %[[ISFIRST:.*]] = fir.load %[[V0]] : !fir.ref<i16>
 129 // CHECK-NEXT:        %[[V19:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 130 // CHECK-NEXT:        %[[V20:.*]] = fir.load %[[V19]] : !fir.ref<i32>
 131 // CHECK-NEXT:        %[[V21:.*]] = arith.cmpi slt, %[[V20]], %arg4 : i32
 132 // CHECK-NEXT:        %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i16) -> i1
 133 // CHECK-NEXT:        %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
 134 // CHECK-NEXT:        %[[ORCOND:.*]] = arith.ori %[[V21]], %[[ISFIRSTNOT]] : i1
 135 // CHECK-NEXT:        %[[V22:.*]] = fir.if %[[ORCOND]] -> (i32) {
 136 // CHECK-NEXT:          fir.store %c1_i16 to %[[V0]] : !fir.ref<i16>
 137 // CHECK-NEXT:          %[[V23:.*]] = hlfir.designate %[[RES]] (%c1) : (!fir.ref<!fir.array<1xi16>>, index) -> !fir.ref<i16>
 138 // CHECK-NEXT:          %[[V24:.*]] = fir.convert %[[V14]] : (index) -> i16
 139 // CHECK-NEXT:          fir.store %[[V24]] to %[[V23]] : !fir.ref<i16>
 140 // CHECK-NEXT:          fir.result %[[V20]] : i32
 141 // CHECK-NEXT:        } else {
 142 // CHECK-NEXT:          fir.result %arg4 : i32
 143 // CHECK-NEXT:        }
 144 // CHECK-NEXT:        fir.result %[[V22]] : i32
 145 // CHECK-NEXT:      } else {
 146 // CHECK-NEXT:        fir.result %arg4 : i32
 147 // CHECK-NEXT:      }
 148 // CHECK-NEXT:      fir.result %[[V18]] : i32
 149 // CHECK-NEXT:    }
 150 // CHECK-NEXT:    %[[BD:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box<!fir.array<?xi16>>, index) -> (index, index, index)
 151 // CHECK-NEXT:    fir.do_loop %arg3 = %c1 to %[[BD]]#1 step %c1 unordered {
 152 // CHECK-NEXT:      %[[V13:.*]] = hlfir.designate %[[RES]] (%arg3)  : (!fir.ref<!fir.array<1xi16>>, index) -> !fir.ref<i16>
 153 // CHECK-NEXT:      %[[V14:.*]] = fir.load %[[V13]] : !fir.ref<i16>
 154 // CHECK-NEXT:      %[[V15:.*]] = hlfir.designate %[[V2]]#0 (%arg3)  : (!fir.box<!fir.array<?xi16>>, index) -> !fir.ref<i16>
 155 // CHECK-NEXT:      hlfir.assign %[[V14]] to %[[V15]] : i16, !fir.ref<i16>
 156 // CHECK-NEXT:    }
 157 // CHECK-NEXT:    return
 158
 159
 160 func.func @_QPtest_kind2_convert(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "m"}) {
 161   %c1 = arith.constant 1 : index
 162   %c0 = arith.constant 0 : index
 163   %0:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 164   %1:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 165   %2:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 166   %3 = fir.load %2#0 : !fir.ref<i32>
 167   %4:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 168   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
 169   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
 170   ^bb0(%arg3: index):
 171     %10 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 172     %11 = fir.load %10 : !fir.ref<i32>
 173     %12 = arith.cmpi sge, %11, %3 : i32
 174     %13 = fir.convert %12 : (i1) -> !fir.logical<4>
 175     hlfir.yield_element %13 : !fir.logical<4>
 176   }
 177   %7 = hlfir.minloc %0#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi16>
 178   %8 = fir.shape %c1 : (index) -> !fir.shape<1>
 179   %9 = hlfir.elemental %8 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 180   ^bb0(%arg3: index):
 181     %10 = hlfir.apply %7, %arg3 : (!hlfir.expr<1xi16>, index) -> i16
 182     %11 = fir.convert %10 : (i16) -> i32
 183     hlfir.yield_element %11 : i32
 184   }
 185   hlfir.assign %9 to %1#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
 186   hlfir.destroy %9 : !hlfir.expr<?xi32>
 187   hlfir.destroy %7 : !hlfir.expr<1xi16>
 188   hlfir.destroy %6 : !hlfir.expr<?x!fir.logical<4>>
 189   return
 190 }
 191 // The minloc has other uses, not an assign that gets optimized out.
 192 // CHECK-LABEL: _QPtest_kind2_convert
 193 // CHECK-SAME:     (%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<i32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "m"}) {
 194 // CHECK-NEXT:   %false = arith.constant false
 195 // CHECK-NEXT:   %true = arith.constant true
 196 // CHECK-NEXT:   %c2147483647_i32 = arith.constant 2147483647 : i32
 197 // CHECK-NEXT:   %c1_i16 = arith.constant 1 : i16
 198 // CHECK-NEXT:   %c0 = arith.constant 0 : index
 199 // CHECK-NEXT:   %c0_i16 = arith.constant 0 : i16
 200 // CHECK-NEXT:   %c1 = arith.constant 1 : index
 201 // CHECK-NEXT:   %[[V0:.*]] = fir.alloca i16
 202 // CHECK-NEXT:   %[[V1:.*]] = fir.alloca !fir.array<1xi16>
 203 // CHECK-NEXT:   %[[V2:.*]]:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 204 // CHECK-NEXT:   %[[V3:.*]]:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 205 // CHECK-NEXT:   %[[V4:.*]]:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 206 // CHECK-NEXT:   %[[V5:.*]] = fir.load %[[V4]]#0 : !fir.ref<i32>
 207 // CHECK-NEXT:   %[[V6:.*]] = hlfir.designate %[[V1]] (%c1)  : (!fir.ref<!fir.array<1xi16>>, index) -> !fir.ref<i16>
 208 // CHECK-NEXT:   fir.store %c0_i16 to %[[V6]] : !fir.ref<i16>
 209 // CHECK-NEXT:   fir.store %c0_i16 to %[[V0]] : !fir.ref<i16>
 210 // CHECK-NEXT:   %[[V7:.*]]:3 = fir.box_dims %[[V2]]#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 211 // CHECK-NEXT:   %[[V8:.*]] = arith.subi %[[V7]]#1, %c1 : index
 212 // CHECK-NEXT:   %[[V9:.*]] = fir.do_loop %arg3 = %c0 to %[[V8]] step %c1 iter_args(%arg4 = %c2147483647_i32) -> (i32) {
 213 // CHECK-NEXT:     %[[V15:.*]] = arith.addi %arg3, %c1 : index
 214 // CHECK-NEXT:     %[[V16:.*]] = hlfir.designate %[[V2]]#0 (%[[V15]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 215 // CHECK-NEXT:     %[[V17:.*]] = fir.load %[[V16]] : !fir.ref<i32>
 216 // CHECK-NEXT:     %[[V18:.*]] = arith.cmpi sge, %[[V17]], %[[V5]] : i32
 217 // CHECK-NEXT:     %[[V19:.*]] = fir.if %[[V18]] -> (i32) {
 218 // CHECK-NEXT:       %[[ISFIRST:.*]] = fir.load %[[V0]] : !fir.ref<i16>
 219 // CHECK-NEXT:       %[[V23:.*]] = hlfir.designate %[[V2]]#0 (%[[V15]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 220 // CHECK-NEXT:       %[[V24:.*]] = fir.load %[[V23]] : !fir.ref<i32>
 221 // CHECK-NEXT:       %[[V25:.*]] = arith.cmpi slt, %[[V24]], %arg4 : i32
 222 // CHECK-NEXT:       %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i16) -> i1
 223 // CHECK-NEXT:       %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
 224 // CHECK-NEXT:       %[[ORCOND:.*]] = arith.ori %[[V25]], %[[ISFIRSTNOT]] : i1
 225 // CHECK-NEXT:       %[[V26:.*]] = fir.if %[[ORCOND]] -> (i32) {
 226 // CHECK-NEXT:         fir.store %c1_i16 to %[[V0]] : !fir.ref<i16>
 227 // CHECK-NEXT:         %[[V27:.*]] = hlfir.designate %[[V1]] (%c1)  : (!fir.ref<!fir.array<1xi16>>, index) -> !fir.ref<i16>
 228 // CHECK-NEXT:         %[[V28:.*]] = fir.convert %[[V15]] : (index) -> i16
 229 // CHECK-NEXT:         fir.store %[[V28]] to %[[V27]] : !fir.ref<i16>
 230 // CHECK-NEXT:         fir.result %[[V24]] : i32
 231 // CHECK-NEXT:       } else {
 232 // CHECK-NEXT:         fir.result %arg4 : i32
 233 // CHECK-NEXT:       }
 234 // CHECK-NEXT:       fir.result %[[V26]] : i32
 235 // CHECK-NEXT:     } else {
 236 // CHECK-NEXT:       fir.result %arg4 : i32
 237 // CHECK-NEXT:     }
 238 // CHECK-NEXT:     fir.result %[[V19]] : i32
 239 // CHECK-NEXT:   }
 240 // CHECK-NEXT:   %[[V12:.*]] = hlfir.as_expr %[[V1]] move %false : (!fir.ref<!fir.array<1xi16>>, i1) -> !hlfir.expr<1xi16>
 241 // CHECK-NEXT:   %[[V13:.*]] = fir.shape %c1 : (index) -> !fir.shape<1>
 242 // CHECK-NEXT:   %[[V14:.*]] = hlfir.elemental %[[V13]] unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 243 // CHECK-NEXT:   ^bb0(%arg3: index):
 244 // CHECK-NEXT:     %[[V15:.*]] = hlfir.apply %[[V12]], %arg3 : (!hlfir.expr<1xi16>, index) -> i16
 245 // CHECK-NEXT:     %[[V16:.*]] = fir.convert %[[V15]] : (i16) -> i32
 246 // CHECK-NEXT:     hlfir.yield_element %[[V16]] : i32
 247 // CHECK-NEXT:   }
 248 // CHECK-NEXT:   hlfir.assign %[[V14]] to %[[V3]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
 249 // CHECK-NEXT:   hlfir.destroy %[[V14]] : !hlfir.expr<?xi32>
 250 // CHECK-NEXT:   return
 251
 252
 253
 254 func.func @_QPtest_float(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<f32> {fir.bindc_name = "val"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "m"}) {
 255   %c0 = arith.constant 0 : index
 256   %0:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEarray"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
 257   %1:2 = hlfir.declare %arg2 {uniq_name = "_QFtestEm"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 258   %2:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
 259   %3 = fir.load %2#0 : !fir.ref<f32>
 260   %4:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 261   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
 262   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
 263   ^bb0(%arg3: index):
 264     %8 = hlfir.designate %0#0 (%arg3)  : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
 265     %9 = fir.load %8 : !fir.ref<f32>
 266     %10 = arith.cmpf oge, %9, %3 : f32
 267     %11 = fir.convert %10 : (i1) -> !fir.logical<4>
 268     hlfir.yield_element %11 : !fir.logical<4>
 269   }
 270   %7 = hlfir.minloc %0#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xf32>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi32>
 271   hlfir.assign %7 to %1#0 : !hlfir.expr<1xi32>, !fir.box<!fir.array<?xi32>>
 272   hlfir.destroy %7 : !hlfir.expr<1xi32>
 273   hlfir.destroy %6 : !hlfir.expr<?x!fir.logical<4>>
 274   return
 275 }
 276 // CHECK-LABEL: _QPtest_float
 277 // CHECK:        %cst = arith.constant 0x7F800000 : f32
 278 // CHECK:        %[[V11:.*]] = fir.do_loop %arg3 = %c0 to %[[V10:.*]] step %c1 iter_args(%arg4 = %cst) -> (f32) {
 279 // CHECK-NEXT:     %[[V14:.*]] = arith.addi %arg3, %c1 : index
 280 // CHECK-NEXT:     %[[V15:.*]] = hlfir.designate %[[V1:.*]]#0 (%[[V14]])  : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
 281 // CHECK-NEXT:     %[[V16:.*]] = fir.load %[[V15]] : !fir.ref<f32>
 282 // CHECK-NEXT:     %[[V17:.*]] = arith.cmpf oge, %[[V16]], %[[V4:.*]] : f32
 283 // CHECK-NEXT:     %[[V18:.*]] = fir.if %[[V17]] -> (f32) {
 284 // CHECK-NEXT:       %[[ISFIRST:.*]] = fir.load %[[V0:.*]] : !fir.ref<i32>
 285 // CHECK-NEXT:       %[[V19:.*]] = hlfir.designate %[[V1]]#0 (%[[V14]]) : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
 286 // CHECK-NEXT:       %[[V20:.*]] = fir.load %[[V19]] : !fir.ref<f32>
 287 // CHECK-NEXT:       %[[NEW_MIN:.*]] = arith.cmpf olt, %[[V20]], %arg4 fastmath<contract> : f32
 288 // CHECK-NEXT:       %[[CONDRED:.*]] = arith.cmpf une, %arg4, %arg4 fastmath<contract> : f32
 289 // CHECK-NEXT:       %[[CONDELEM:.*]] = arith.cmpf oeq, %[[V20]], %[[V20]] fastmath<contract> : f32
 290 // CHECK-NEXT:       %[[ANDCOND:.*]] = arith.andi %[[CONDRED]], %[[CONDELEM]] : i1
 291 // CHECK-NEXT:       %[[NEW_MIN2:.*]] = arith.ori %[[NEW_MIN]], %[[ANDCOND]] : i1
 292 // CHECK-NEXT:       %[[ISFIRSTL:.*]] = fir.convert %[[ISFIRST]] : (i32) -> i1
 293 // CHECK-NEXT:       %[[ISFIRSTNOT:.*]] = arith.xori %[[ISFIRSTL]], %true : i1
 294 // CHECK-NEXT:       %[[ORCOND:.*]] = arith.ori %[[NEW_MIN2]], %[[ISFIRSTNOT]] : i1
 295 // CHECK-NEXT:       %[[V22:.*]] = fir.if %[[ORCOND]] -> (f32) {
 296 // CHECK-NEXT:         fir.store %c1_i32 to %[[V0]] : !fir.ref<i32>
 297 // CHECK-NEXT:         %[[V23:.*]] = hlfir.designate %{{.}} (%c1) : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
 298 // CHECK-NEXT:         %[[V24:.*]] = fir.convert %[[V14]] : (index) -> i32
 299 // CHECK-NEXT:         fir.store %[[V24]] to %[[V23]] : !fir.ref<i32>
 300 // CHECK-NEXT:         fir.result %[[V20]] : f32
 301 // CHECK-NEXT:       } else {
 302 // CHECK-NEXT:         fir.result %arg4 : f32
 303 // CHECK-NEXT:       }
 304 // CHECK-NEXT:       fir.result %[[V22]] : f32
 305 // CHECK-NEXT:     } else {
 306 // CHECK-NEXT:       fir.result %arg4 : f32
 307 // CHECK-NEXT:     }
 308 // CHECK-NEXT:     fir.result %[[V18]] : f32
 309 // CHECK-NEXT:   }
 310
 311
 312 func.func @_QPtest_assignshape(%arg0: !fir.ref<!fir.array<3x3xf32>> {fir.bindc_name = "array"}, %arg1: !fir.ref<f32> {fir.bindc_name = "val"}, %arg2: !fir.ref<!fir.array<3xi32>> {fir.bindc_name = "m"}) {
 313   %c2 = arith.constant 2 : index
 314   %c1 = arith.constant 1 : index
 315   %c3 = arith.constant 3 : index
 316   %0 = fir.shape %c3, %c3 : (index, index) -> !fir.shape<2>
 317   %1:2 = hlfir.declare %arg0(%0) {uniq_name = "_QFtestEarray"} : (!fir.ref<!fir.array<3x3xf32>>, !fir.shape<2>) -> (!fir.ref<!fir.array<3x3xf32>>, !fir.ref<!fir.array<3x3xf32>>)
 318   %2 = fir.shape %c3 : (index) -> !fir.shape<1>
 319   %3:2 = hlfir.declare %arg2(%2) {uniq_name = "_QFtestEm"} : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<3xi32>>, !fir.ref<!fir.array<3xi32>>)
 320   %4:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEval"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
 321   %5 = fir.load %4#0 : !fir.ref<f32>
 322   %6 = hlfir.elemental %0 unordered : (!fir.shape<2>) -> !hlfir.expr<3x3x!fir.logical<4>> {
 323   ^bb0(%arg3: index, %arg4: index):
 324     %10 = hlfir.designate %1#0 (%arg3, %arg4)  : (!fir.ref<!fir.array<3x3xf32>>, index, index) -> !fir.ref<f32>
 325     %11 = fir.load %10 : !fir.ref<f32>
 326     %12 = arith.cmpf oge, %11, %5 : f32
 327     %13 = fir.convert %12 : (i1) -> !fir.logical<4>
 328     hlfir.yield_element %13 : !fir.logical<4>
 329   }
 330   %7 = hlfir.minloc %1#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.ref<!fir.array<3x3xf32>>, !hlfir.expr<3x3x!fir.logical<4>>) -> !hlfir.expr<2xi32>
 331   %8 = fir.shape %c2 : (index) -> !fir.shape<1>
 332   %9 = hlfir.designate %3#0 (%c1:%c2:%c1)  shape %8 : (!fir.ref<!fir.array<3xi32>>, index, index, index, !fir.shape<1>) -> !fir.ref<!fir.array<2xi32>>
 333   hlfir.assign %7 to %9 : !hlfir.expr<2xi32>, !fir.ref<!fir.array<2xi32>>
 334   hlfir.destroy %7 : !hlfir.expr<2xi32>
 335   hlfir.destroy %6 : !hlfir.expr<3x3x!fir.logical<4>>
 336   return
 337 }
 338 // Not supported as the input is not a box
 339 // CHECK-LABEL: _QPtest_assignshape
 340 // CHECK: hlfir.minloc
 341
 342
 343 func.func @_QFPtest_character(%arg0: !fir.box<!fir.array<?x!fir.char<1>>> {fir.bindc_name = "b"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}, %arg2: !fir.ref<i32> {fir.bindc_name = "val"}) -> i32 {
 344   %c0 = arith.constant 0 : index
 345   %c1 = arith.constant 1 : index
 346   %0:2 = hlfir.declare %arg0 typeparams %c1 {uniq_name = "_QFFtestEb"} : (!fir.box<!fir.array<?x!fir.char<1>>>, index) -> (!fir.box<!fir.array<?x!fir.char<1>>>, !fir.box<!fir.array<?x!fir.char<1>>>)
 347   %1:2 = hlfir.declare %arg1 {uniq_name = "_QFFtestEc"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 348   %2 = fir.alloca !fir.array<1xi32> {bindc_name = "m", uniq_name = "_QFFtestEm"}
 349   %3 = fir.shape %c1 : (index) -> !fir.shape<1>
 350   %4:2 = hlfir.declare %2(%3) {uniq_name = "_QFFtestEm"} : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<1xi32>>, !fir.ref<!fir.array<1xi32>>)
 351   %5 = fir.alloca i32 {bindc_name = "test", uniq_name = "_QFFtestEtest"}
 352   %6:2 = hlfir.declare %5 {uniq_name = "_QFFtestEtest"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 353   %7:2 = hlfir.declare %arg2 {uniq_name = "_QFFtestEval"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 354   %8 = fir.load %7#0 : !fir.ref<i32>
 355   %9:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 356   %10 = fir.shape %9#1 : (index) -> !fir.shape<1>
 357   %11 = hlfir.elemental %10 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
 358   ^bb0(%arg3: index):
 359     %16 = hlfir.designate %1#0 (%arg3)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 360     %17 = fir.load %16 : !fir.ref<i32>
 361     %18 = arith.cmpi eq, %17, %8 : i32
 362     %19 = fir.convert %18 : (i1) -> !fir.logical<4>
 363     hlfir.yield_element %19 : !fir.logical<4>
 364   }
 365   %12 = hlfir.minloc %0#0 mask %11 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x!fir.char<1>>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi32>
 366   hlfir.assign %12 to %4#0 : !hlfir.expr<1xi32>, !fir.ref<!fir.array<1xi32>>
 367   hlfir.destroy %12 : !hlfir.expr<1xi32>
 368   hlfir.destroy %11 : !hlfir.expr<?x!fir.logical<4>>
 369   %13 = hlfir.designate %4#0 (%c1)  : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
 370   %14 = fir.load %13 : !fir.ref<i32>
 371   hlfir.assign %14 to %6#0 : i32, !fir.ref<i32>
 372   %15 = fir.load %6#1 : !fir.ref<i32>
 373   return %15 : i32
 374 }
 375 // Characters are not supported at the moment
 376 // CHECK-LABEL: _QFPtest_character
 377 // CHECK: hlfir.minloc
 378
 379
 380 func.func @_QPtest_parts(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "x"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "mask"}) -> f32 {
 381   %c1 = arith.constant 1 : index
 382   %c5 = arith.constant 5 : index
 383   %c0 = arith.constant 0 : index
 384   %c5_i32 = arith.constant 5 : i32
 385   %0:2 = hlfir.declare %arg1 {uniq_name = "_QFtestEmask"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 386   %1 = fir.alloca f32 {bindc_name = "test", uniq_name = "_QFtestEtest"}
 387   %2:2 = hlfir.declare %1 {uniq_name = "_QFtestEtest"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
 388   %3:2 = hlfir.declare %arg0 {uniq_name = "_QFtestEx"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 389   %4:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 390   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
 391   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<4>> {
 392   ^bb0(%arg2: index):
 393     %11 = hlfir.designate %0#0 (%arg2)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 394     %12 = fir.load %11 : !fir.ref<i32>
 395     %13 = arith.cmpi sge, %12, %c5_i32 : i32
 396     %14 = fir.convert %13 : (i1) -> !fir.logical<4>
 397     hlfir.yield_element %14 : !fir.logical<4>
 398   }
 399   %7 = hlfir.minloc %3#0 mask %6 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !hlfir.expr<?x!fir.logical<4>>) -> !hlfir.expr<1xi32>
 400   %8 = fir.shape %c1 : (index) -> !fir.shape<1>
 401   %9 = hlfir.designate %3#0 (%c5:%c5:%c1)  shape %8 : (!fir.box<!fir.array<?xi32>>, index, index, index, !fir.shape<1>) -> !fir.box<!fir.array<1xi32>>
 402   hlfir.assign %7 to %9 : !hlfir.expr<1xi32>, !fir.box<!fir.array<1xi32>>
 403   hlfir.destroy %7 : !hlfir.expr<1xi32>
 404   hlfir.destroy %6 : !hlfir.expr<?x!fir.logical<4>>
 405   %10 = fir.load %2#1 : !fir.ref<f32>
 406   return %10 : f32
 407 }
 408 // Characters are not supported at the moment
 409 // CHECK-LABEL: _QPtest_parts
 410 // CHECK: fir.do_loop %{{.*}} = %c0 to %{{.*}} step %c1 iter_args(%{{.*}} = %c2147483647_i32) -> (i32) {
 411