flang/test/HLFIR/inline-elemental.fir

   1 // RUN: fir-opt --inline-elementals %s | FileCheck %s
   2
   3 // check inlining one elemental into another
   4 // a = b * c + d
   5 func.func @inline_to_elemental(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}, %arg3: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}) {
   6   %0:2 = hlfir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
   7   %1:2 = hlfir.declare %arg1 {uniq_name = "b"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
   8   %2:2 = hlfir.declare %arg2 {uniq_name = "c"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
   9   %3:2 = hlfir.declare %arg3 {uniq_name = "d"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  10   %c0 = arith.constant 0 : index
  11   %4:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  12   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
  13   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
  14   ^bb0(%arg4: index):
  15     %8 = hlfir.designate %1#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  16     %9 = hlfir.designate %2#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  17     %10 = fir.load %8 : !fir.ref<i32>
  18     %11 = fir.load %9 : !fir.ref<i32>
  19     %12 = arith.muli %10, %11 : i32
  20     hlfir.yield_element %12 : i32
  21   }
  22   %7 = hlfir.elemental %5 : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
  23   ^bb0(%arg4: index):
  24     %8 = hlfir.apply %6, %arg4 : (!hlfir.expr<?xi32>, index) -> i32
  25     %9 = hlfir.designate %3#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  26     %10 = fir.load %9 : !fir.ref<i32>
  27     %11 = arith.addi %8, %10 : i32
  28     hlfir.yield_element %11 : i32
  29   }
  30   hlfir.assign %7 to %0#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
  31   hlfir.destroy %7 : !hlfir.expr<?xi32>
  32   hlfir.destroy %6 : !hlfir.expr<?xi32>
  33   return
  34 }
  35 // CHECK-LABEL: func.func @inline_to_elemental
  36 // CHECK-SAME:      %[[A_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}
  37 // CHECK-SAME:      %[[B_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}
  38 // CHECK-SAME:      %[[C_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}
  39 // CHECK-SAME:      %[[D_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}
  40 // CHECK-NEXT:    %[[C0:.*]] = arith.constant 0 : index
  41 // CHECK-DAG:     %[[A:.*]]:2 = hlfir.declare %[[A_ARG]]
  42 // CHECK-DAG:     %[[B:.*]]:2 = hlfir.declare %[[B_ARG]]
  43 // CHECK-DAG:     %[[C:.*]]:2 = hlfir.declare %[[C_ARG]]
  44 // CHECK-DAG:     %[[D:.*]]:2 = hlfir.declare %[[D_ARG]]
  45 // CHECK-NEXT:    %[[B_DIM0:.*]]:3 = fir.box_dims %[[B]]#0, %[[C0]]
  46 // CHECK-NEXT:    %[[B_SHAPE:.*]] = fir.shape %[[B_DIM0]]#1
  47 // CHECK-NEXT:    %[[EXPR:.*]] = hlfir.elemental %[[B_SHAPE]]
  48 // CHECK-NEXT:    ^bb0(%[[I:.*]]: index):
  49 // inline the first elemental:
  50 // CHECK-NEXT:      %[[B_I_REF:.*]] = hlfir.designate %[[B]]#0 (%[[I]])
  51 // CHECK-NEXT:      %[[C_I_REF:.*]] = hlfir.designate %[[C]]#0 (%[[I]])
  52 // CHECK-NEXT:      %[[B_I:.*]] = fir.load %[[B_I_REF]]
  53 // CHECK-NEXT:      %[[C_I:.*]] = fir.load %[[C_I_REF]]
  54 // CHECK-NEXT:      %[[MUL:.*]] = arith.muli %[[B_I]], %[[C_I]]
  55 // second elemental:
  56 // CHECK-NEXT:      %[[D_I_REF:.*]] = hlfir.designate %[[D]]#0 (%[[I]])
  57 // CHECK-NEXT:      %[[D_I:.*]] = fir.load %[[D_I_REF]]
  58 // CHECK-NEXT:      %[[ADD:.*]] = arith.addi %[[MUL]], %[[D_I]]
  59 // CHECK-NEXT:      hlfir.yield_element %[[ADD]]
  60 // CHECK-NEXT:    }
  61 // CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[A]]#0
  62 // CHECK-NEXT:    hlfir.destroy %[[EXPR]]
  63 // CHECK-NEXT:    return
  64 // CHECK-NEXT:  }
  65
  66 // check inlining into a do_loop
  67 func.func @inline_to_loop(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}, %arg3: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}) {
  68   %0:2 = hlfir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  69   %1:2 = hlfir.declare %arg1 {uniq_name = "b"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  70   %2:2 = hlfir.declare %arg2 {uniq_name = "c"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  71   %3:2 = hlfir.declare %arg3 {uniq_name = "d"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
  72   %c0 = arith.constant 0 : index
  73   %4:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
  74   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
  75   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
  76   ^bb0(%arg4: index):
  77     %8 = hlfir.designate %1#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  78     %9 = hlfir.designate %2#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  79     %10 = fir.load %8 : !fir.ref<i32>
  80     %11 = fir.load %9 : !fir.ref<i32>
  81     %12 = arith.muli %10, %11 : i32
  82     hlfir.yield_element %12 : i32
  83   }
  84   %array = fir.array_load %0#0 : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
  85   %c1 = arith.constant 1 : index
  86   %max = arith.subi %4#1, %c1 : index
  87   %7 = fir.do_loop %arg4 = %c0 to %max step %c1 unordered iter_args(%arg5 = %array) -> (!fir.array<?xi32>) {
  88     %8 = hlfir.apply %6, %arg4 : (!hlfir.expr<?xi32>, index) -> i32
  89     %9 = hlfir.designate %3#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
  90     %10 = fir.load %9 : !fir.ref<i32>
  91     %11 = arith.addi %8, %10 : i32
  92     %12 = fir.array_update %arg5, %11, %arg4 : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
  93     fir.result %12 : !fir.array<?xi32>
  94   }
  95   fir.array_merge_store %array, %7 to %arg0 : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
  96   hlfir.destroy %6 : !hlfir.expr<?xi32>
  97   return
  98 }
  99 // CHECK-LABEL: func.func @inline_to_loop
 100 // CHECK-SAME:      %[[A_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}
 101 // CHECK-SAME:      %[[B_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}
 102 // CHECK-SAME:      %[[C_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}
 103 // CHECK-SAME:      %[[D_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}
 104 // CHECK-DAG:     %[[C1:.*]] = arith.constant 1 : index
 105 // CHECK-DAG:     %[[C0:.*]] = arith.constant 0 : index
 106 // CHECK-DAG:     %[[A:.*]]:2 = hlfir.declare %[[A_ARG]]
 107 // CHECK-DAG:     %[[B:.*]]:2 = hlfir.declare %[[B_ARG]]
 108 // CHECK-DAG:     %[[C:.*]]:2 = hlfir.declare %[[C_ARG]]
 109 // CHECK-DAG:     %[[D:.*]]:2 = hlfir.declare %[[D_ARG]]
 110 // CHECK-NEXT:    %[[B_DIM0:.*]]:3 = fir.box_dims %[[B]]#0, %[[C0]]
 111 // CHECK-NEXT:    %[[ARRAY:.*]] = fir.array_load %[[A]]#0
 112 // CHECK-NEXT:    %[[MAX:.*]] = arith.subi %[[B_DIM0]]#1, %[[C1]]
 113 // CHECK-NEXT:    %[[LOOP:.*]] = fir.do_loop %[[I:.*]] = %[[C0]] to %[[MAX]] step %[[C1]] unordered iter_args(%[[LOOP_ARRAY:.*]] = %[[ARRAY]])
 114 // inline the elemental:
 115 // CHECK-NEXT:      %[[B_I_REF:.*]] = hlfir.designate %[[B]]#0 (%[[I]])
 116 // CHECK-NEXT:      %[[C_I_REF:.*]] = hlfir.designate %[[C]]#0 (%[[I]])
 117 // CHECK-NEXT:      %[[B_I:.*]] = fir.load %[[B_I_REF]]
 118 // CHECK-NEXT:      %[[C_I:.*]] = fir.load %[[C_I_REF]]
 119 // CHECK-NEXT:      %[[MUL:.*]] = arith.muli %[[B_I]], %[[C_I]]
 120 // loop body:
 121 // CHECK-NEXT:      %[[D_I_REF:.*]] = hlfir.designate %[[D]]#0 (%[[I]])
 122 // CHECK-NEXT:      %[[D_I:.*]] = fir.load %[[D_I_REF]]
 123 // CHECK-NEXT:      %[[ADD:.*]] = arith.addi %[[MUL]], %[[D_I]]
 124 // CHECK-NEXT:      %[[ARRAY_UPD:.*]] = fir.array_update %[[LOOP_ARRAY]], %[[ADD]], %[[I]]
 125 // CHECK-NEXT:      fir.result %[[ARRAY_UPD]]
 126 // CHECK-NEXT:    }
 127 // CHECK-NEXT:    fir.array_merge_store %[[ARRAY]], %[[LOOP]] to %[[A_ARG]]
 128 // CHECK-NEXT:    return
 129 // CHECK-NEXT:  }
 130
 131 // inlining into a single hlfir.apply
 132 // a = (b * c)[1]
 133 func.func @inline_to_apply(%arg0: !fir.ref<i32> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}) {
 134   %0:2 = hlfir.declare %arg0 {uniq_name = "a"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 135   %1:2 = hlfir.declare %arg1 {uniq_name = "b"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 136   %2:2 = hlfir.declare %arg2 {uniq_name = "c"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 137   %c0 = arith.constant 0 : index
 138   %4:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 139   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
 140   %6 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 141   ^bb0(%arg4: index):
 142     %8 = hlfir.designate %1#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 143     %9 = hlfir.designate %2#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 144     %10 = fir.load %8 : !fir.ref<i32>
 145     %11 = fir.load %9 : !fir.ref<i32>
 146     %12 = arith.muli %10, %11 : i32
 147     hlfir.yield_element %12 : i32
 148   }
 149   %c1 = arith.constant 1 : index
 150   %res = hlfir.apply %6, %c1 : (!hlfir.expr<?xi32>, index) -> i32
 151   fir.store %res to %0#0 : !fir.ref<i32>
 152   hlfir.destroy %6 : !hlfir.expr<?xi32>
 153   return
 154 }
 155 // CHECK-LABEL: func.func @inline_to_apply
 156 // CHECK-SAME:      %[[A_ARG:.*]]: !fir.ref<i32> {fir.bindc_name = "a"}
 157 // CHECK-SAME:      %[[B_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}
 158 // CHECK-SAME:      %[[C_ARG:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}
 159 // CHECK-DAG:     %[[C1:.*]] = arith.constant 1 : index
 160 // CHECK-DAG:     %[[A:.*]]:2 = hlfir.declare %[[A_ARG]]
 161 // CHECK-DAG:     %[[B:.*]]:2 = hlfir.declare %[[B_ARG]]
 162 // CHECK-DAG:     %[[C:.*]]:2 = hlfir.declare %[[C_ARG]]
 163 // inline the elemental:
 164 // CHECK-NEXT:    %[[B_1_REF:.*]] = hlfir.designate %[[B]]#0 (%[[C1]])
 165 // CHECK-NEXT:    %[[C_1_REF:.*]] = hlfir.designate %[[C]]#0 (%[[C1]])
 166 // CHECK-NEXT:    %[[B_1:.*]] = fir.load %[[B_1_REF]]
 167 // CHECK-NEXT:    %[[C_1:.*]] = fir.load %[[C_1_REF]]
 168 // CHECK-NEXT:    %[[MUL:.*]] = arith.muli %[[B_1]], %[[C_1]]
 169 // store:
 170 // CHECK-NEXT:    fir.store %[[MUL]] to %0#0 : !fir.ref<i32>
 171 // CHECK-NEXT:    return
 172 // CHECK-NEXT:  }
 173
 174 // Check long chains of elementals
 175 // subroutine reproducer(a)
 176 //   real, dimension(:) :: a
 177 //   a = sqrt(a * (a - 1))
 178 // end subroutine
 179 func.func @_QPreproducer(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}) {
 180   %0:2 = hlfir.declare %arg0 {uniq_name = "_QFreproducerEa"} : (!fir.box<!fir.array<?xf32>>) -> (!fir.box<!fir.array<?xf32>>, !fir.box<!fir.array<?xf32>>)
 181   %cst = arith.constant 1.000000e+00 : f32
 182   %c0 = arith.constant 0 : index
 183   %1:3 = fir.box_dims %0#0, %c0 : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 184   %2 = fir.shape %1#1 : (index) -> !fir.shape<1>
 185   %3 = hlfir.elemental %2 unordered : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
 186   ^bb0(%arg1: index):
 187     %9 = hlfir.designate %0#0 (%arg1)  : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
 188     %10 = fir.load %9 : !fir.ref<f32>
 189     %11 = arith.subf %10, %cst fastmath<contract> : f32
 190     hlfir.yield_element %11 : f32
 191   }
 192   %4 = hlfir.elemental %2 unordered : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
 193   ^bb0(%arg1: index):
 194     %9 = hlfir.apply %3, %arg1 : (!hlfir.expr<?xf32>, index) -> f32
 195     %10 = hlfir.no_reassoc %9 : f32
 196     hlfir.yield_element %10 : f32
 197   }
 198   %c0_0 = arith.constant 0 : index
 199   %5:3 = fir.box_dims %0#0, %c0_0 : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
 200   %6 = fir.shape %5#1 : (index) -> !fir.shape<1>
 201   %7 = hlfir.elemental %6 unordered : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
 202   ^bb0(%arg1: index):
 203     %9 = hlfir.designate %0#0 (%arg1)  : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
 204     %10 = hlfir.apply %4, %arg1 : (!hlfir.expr<?xf32>, index) -> f32
 205     %11 = fir.load %9 : !fir.ref<f32>
 206     %12 = arith.mulf %11, %10 fastmath<contract> : f32
 207     hlfir.yield_element %12 : f32
 208   }
 209   %8 = hlfir.elemental %6 : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
 210   ^bb0(%arg1: index):
 211     %9 = hlfir.apply %7, %arg1 : (!hlfir.expr<?xf32>, index) -> f32
 212     %10 = math.sqrt %9 fastmath<contract> : f32
 213     hlfir.yield_element %10 : f32
 214   }
 215   hlfir.assign %8 to %0#0 : !hlfir.expr<?xf32>, !fir.box<!fir.array<?xf32>>
 216   hlfir.destroy %8 : !hlfir.expr<?xf32>
 217   hlfir.destroy %7 : !hlfir.expr<?xf32>
 218   hlfir.destroy %4 : !hlfir.expr<?xf32>
 219   hlfir.destroy %3 : !hlfir.expr<?xf32>
 220   return
 221 }
 222 // CHECK-LABEL: func.func @_QPreproducer
 223 // CHECK-SAME:      %[[A_ARG:.*]]: !fir.box<!fir.array<?xf32>> {fir.bindc_name = "a"}
 224 // CHECK-DAG:     %[[CST:.*]] = arith.constant 1.0000
 225 // CHECK-DAG:     %[[C0:.*]] = arith.constant 0
 226 // CHECK-DAG:     %[[A_VAR:.*]]:2 = hlfir.declare %[[A_ARG]]
 227 // CHECK-NEXT:    %[[A_DIMS_0:.*]]:3 = fir.box_dims %[[A_VAR]]#0, %[[C0]]
 228 // CHECK-NEXT:    %[[SHAPE_0:.*]] = fir.shape %[[A_DIMS_0]]#1
 229 // all in one elemental:
 230 // CHECK-NEXT:    %[[EXPR:.*]] = hlfir.elemental %[[SHAPE_0]]
 231 // CHECK-NEXT:    ^bb0(%[[I:.*]]: index):
 232 // CHECK-NEXT:      %[[A_I0:.*]] = hlfir.designate %[[A_VAR]]#0 (%[[I]])
 233 // CHECK-NEXT:      %[[A_I1:.*]] = hlfir.designate %[[A_VAR]]#0 (%[[I]])
 234 // CHECK-NEXT:      %[[A_I1_VAL:.*]] = fir.load %[[A_I1]]
 235 // CHECK-NEXT:      %[[SUB:.*]] = arith.subf %[[A_I1_VAL]], %[[CST]]
 236 // CHECK-NEXT:      %[[SUB0:.*]] = hlfir.no_reassoc %[[SUB]] : f32
 237 // CHECK-NEXT:      %[[A_I0_VAL:.*]] = fir.load %[[A_I0]]
 238 // CHECK-NEXT:      %[[MUL:.*]] = arith.mulf %[[A_I0_VAL]], %[[SUB0]]
 239 // CHECK-NEXT:      %[[SQRT:.*]] = math.sqrt %[[MUL]]
 240 // CHECK-NEXT:      hlfir.yield_element %[[SQRT]]
 241 // CHECK-NEXT:    }
 242 // CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[A_VAR]]#0
 243 // CHECK-NEXT:    hlfir.destroy %[[EXPR]]
 244 // CHECK-NEXT:    return
 245 // CHECK-NEXT:  }
 246
 247 // Check that the ordered elemental is not inlined into another:
 248 // a = b + c + d
 249 func.func @noinline_ordered(%arg0: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %arg1: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"}, %arg2: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"}, %arg3: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}) {
 250   %0:2 = hlfir.declare %arg0 {uniq_name = "a"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 251   %1:2 = hlfir.declare %arg1 {uniq_name = "b"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 252   %2:2 = hlfir.declare %arg2 {uniq_name = "c"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 253   %3:2 = hlfir.declare %arg3 {uniq_name = "d"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 254   %c0 = arith.constant 0 : index
 255   %4:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 256   %5 = fir.shape %4#1 : (index) -> !fir.shape<1>
 257   %6 = hlfir.elemental %5 : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 258   ^bb0(%arg4: index):
 259     %8 = hlfir.designate %1#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 260     %9 = hlfir.designate %2#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 261     %10 = fir.load %8 : !fir.ref<i32>
 262     %11 = fir.load %9 : !fir.ref<i32>
 263     %12 = arith.muli %10, %11 : i32
 264     hlfir.yield_element %12 : i32
 265   }
 266   %7 = hlfir.elemental %5 unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 267   ^bb0(%arg4: index):
 268     %8 = hlfir.apply %6, %arg4 : (!hlfir.expr<?xi32>, index) -> i32
 269     %9 = hlfir.designate %3#0 (%arg4)  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 270     %10 = fir.load %9 : !fir.ref<i32>
 271     %11 = arith.addi %8, %10 : i32
 272     hlfir.yield_element %11 : i32
 273   }
 274   hlfir.assign %7 to %0#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
 275   hlfir.destroy %7 : !hlfir.expr<?xi32>
 276   hlfir.destroy %6 : !hlfir.expr<?xi32>
 277   return
 278 }
 279 // CHECK-LABEL:   func.func @noinline_ordered(
 280 // CHECK-SAME:      %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"},
 281 // CHECK-SAME:      %[[VAL_1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "b"},
 282 // CHECK-SAME:      %[[VAL_2:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "c"},
 283 // CHECK-SAME:      %[[VAL_3:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "d"}) {
 284 // CHECK:           %[[VAL_4:.*]] = arith.constant 0 : index
 285 // CHECK:           %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "a"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 286 // CHECK:           %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_1]] {uniq_name = "b"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 287 // CHECK:           %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_2]] {uniq_name = "c"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 288 // CHECK:           %[[VAL_8:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "d"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 289 // CHECK:           %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_6]]#0, %[[VAL_4]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
 290 // CHECK:           %[[VAL_10:.*]] = fir.shape %[[VAL_9]]#1 : (index) -> !fir.shape<1>
 291 // CHECK:           %[[VAL_11:.*]] = hlfir.elemental %[[VAL_10]] : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 292 // CHECK:           ^bb0(%[[VAL_12:.*]]: index):
 293 // CHECK:             %[[VAL_13:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_12]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 294 // CHECK:             %[[VAL_14:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_12]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 295 // CHECK:             %[[VAL_15:.*]] = fir.load %[[VAL_13]] : !fir.ref<i32>
 296 // CHECK:             %[[VAL_16:.*]] = fir.load %[[VAL_14]] : !fir.ref<i32>
 297 // CHECK:             %[[VAL_17:.*]] = arith.muli %[[VAL_15]], %[[VAL_16]] : i32
 298 // CHECK:             hlfir.yield_element %[[VAL_17]] : i32
 299 // CHECK:           }
 300 // CHECK:           %[[VAL_18:.*]] = hlfir.elemental %[[VAL_10]] unordered : (!fir.shape<1>) -> !hlfir.expr<?xi32> {
 301 // CHECK:           ^bb0(%[[VAL_19:.*]]: index):
 302 // CHECK:             %[[VAL_20:.*]] = hlfir.apply %[[VAL_21:.*]], %[[VAL_19]] : (!hlfir.expr<?xi32>, index) -> i32
 303 // CHECK:             %[[VAL_22:.*]] = hlfir.designate %[[VAL_8]]#0 (%[[VAL_19]])  : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
 304 // CHECK:             %[[VAL_23:.*]] = fir.load %[[VAL_22]] : !fir.ref<i32>
 305 // CHECK:             %[[VAL_24:.*]] = arith.addi %[[VAL_20]], %[[VAL_23]] : i32
 306 // CHECK:             hlfir.yield_element %[[VAL_24]] : i32
 307 // CHECK:           }
 308 // CHECK:           hlfir.assign %[[VAL_25:.*]] to %[[VAL_5]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
 309 // CHECK:           hlfir.destroy %[[VAL_25]] : !hlfir.expr<?xi32>
 310 // CHECK:           hlfir.destroy %[[VAL_26:.*]] : !hlfir.expr<?xi32>
 311 // CHECK:           return
 312 // CHECK:         }
 313
 314 // Check that the elemental is not inlined, because its array result
 315 // must be finalized.
 316 // FIXME: the inlining is actually blocked by the type check
 317 // between the yield_element and apply. When this is fixed,
 318 // the test should keep passing.
 319 func.func @noinline_due_to_finalization(%arg0: !fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>> {fir.bindc_name = "x"}) {
 320   %c0 = arith.constant 0 : index
 321   %0 = fir.alloca !fir.type<_QMtypesTt1{x:f32}> {bindc_name = ".result"}
 322   %1:2 = hlfir.declare %arg0 {uniq_name = "_QFtest1Ex"} : (!fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>) -> (!fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>, !fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>)
 323   %2:3 = fir.box_dims %1#0, %c0 : (!fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>, index) -> (index, index, index)
 324   %3 = fir.shape %2#1 : (index) -> !fir.shape<1>
 325   %4 = hlfir.elemental %3 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>> {
 326   ^bb0(%arg1: index):
 327     %6 = hlfir.designate %1#0 (%arg1)  : (!fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>, index) -> !fir.ref<!fir.type<_QMtypesTt1{x:f32}>>
 328     %7 = fir.call @_QPelem1(%6) fastmath<contract> : (!fir.ref<!fir.type<_QMtypesTt1{x:f32}>>) -> !fir.type<_QMtypesTt1{x:f32}>
 329     fir.save_result %7 to %0 : !fir.type<_QMtypesTt1{x:f32}>, !fir.ref<!fir.type<_QMtypesTt1{x:f32}>>
 330     %8:2 = hlfir.declare %0 {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.type<_QMtypesTt1{x:f32}>>) -> (!fir.ref<!fir.type<_QMtypesTt1{x:f32}>>, !fir.ref<!fir.type<_QMtypesTt1{x:f32}>>)
 331     hlfir.yield_element %8#0 : !fir.ref<!fir.type<_QMtypesTt1{x:f32}>>
 332   }
 333   %5 = hlfir.elemental %3 unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>> {
 334   ^bb0(%arg1: index):
 335     %6 = hlfir.apply %4, %arg1 : (!hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>, index) -> !hlfir.expr<!fir.type<_QMtypesTt1{x:f32}>>
 336     %7 = hlfir.no_reassoc %6 : !hlfir.expr<!fir.type<_QMtypesTt1{x:f32}>>
 337     hlfir.yield_element %7 : !hlfir.expr<!fir.type<_QMtypesTt1{x:f32}>>
 338   }
 339   hlfir.assign %5 to %1#0 : !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>, !fir.box<!fir.array<?x!fir.type<_QMtypesTt1{x:f32}>>>
 340   hlfir.destroy %5 : !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>
 341   hlfir.destroy %4 finalize : !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>
 342   return
 343 }
 344 // CHECK-LABEL:   func.func @noinline_due_to_finalization(
 345 // CHECK:           %[[VAL_6:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>> {
 346 // CHECK:           %[[VAL_11:.*]] = hlfir.elemental %{{.*}} unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>> {
 347 // CHECK:             %[[VAL_13:.*]] = hlfir.apply %[[VAL_6]], %{{.*}} : (!hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>, index) -> !hlfir.expr<!fir.type<_QMtypesTt1{x:f32}>>
 348 // CHECK:           hlfir.destroy %[[VAL_11]] : !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>
 349 // CHECK:           hlfir.destroy %[[VAL_6]] finalize : !hlfir.expr<?x!fir.type<_QMtypesTt1{x:f32}>>