217 lines · plain
1// Test code generation of hlfir.region_assign when the LHS computed2// address must be saved before the assignment is evaluated. Because3// the assignment would modify the LHS evaluation.4// RUN: fir-opt %s --lower-hlfir-ordered-assignments | FileCheck %s5 6// Test simplified IR for:7//8// x(x(1):x(2)) = l9//10// Verify that, although a conflict is detected, the LHS is not saved11// on a descriptor stack: it is already in a register that can be used12// since there is no forall.13 14func.func @save_box_in_ssa_register(%arg0: !fir.box<!fir.array<?xi64>>, %arg1: !fir.box<!fir.array<?x!fir.logical<4>>>) {15 %c2 = arith.constant 2 : index16 %c1 = arith.constant 1 : index17 %0:2 = hlfir.declare %arg1 {uniq_name = "l"} : (!fir.box<!fir.array<?x!fir.logical<4>>>) -> (!fir.box<!fir.array<?x!fir.logical<4>>>, !fir.box<!fir.array<?x!fir.logical<4>>>)18 %1:2 = hlfir.declare %arg0 {uniq_name = "x"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)19 hlfir.region_assign {20 hlfir.yield %0#0 : !fir.box<!fir.array<?x!fir.logical<4>>>21 } to {22 %2 = hlfir.designate %1#0 (%c1) : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>23 %3 = fir.load %2 : !fir.ref<i64>24 %4 = hlfir.designate %1#0 (%c2) : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>25 %5 = fir.load %4 : !fir.ref<i64>26 %6 = arith.subi %5, %3 : i6427 %7 = fir.convert %6 : (i64) -> index28 %8 = fir.shape %7 : (index) -> !fir.shape<1>29 %9 = hlfir.designate %1#0 (%3:%5:%c1) shape %8 : (!fir.box<!fir.array<?xi64>>, i64, i64, index, !fir.shape<1>) -> !fir.box<!fir.array<?xi64>>30 hlfir.yield %9 : !fir.box<!fir.array<?xi64>>31 } user_defined_assign (%arg2: !fir.ref<!fir.logical<4>>) to (%arg3: !fir.ref<i64>) {32 %2 = fir.load %arg2 : !fir.ref<!fir.logical<4>>33 fir.call @logical_to_real(%arg3, %2) : (!fir.ref<i64>, !fir.logical<4>) -> ()34 }35 return36}37// CHECK-LABEL: func.func @save_box_in_ssa_register(38// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi64>>,39// CHECK-SAME: %[[VAL_1:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>) {40// CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "x"} : (!fir.box<!fir.array<?xi64>>) -> (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>)41// CHECK: %[[VAL_18:.*]] = hlfir.designate %[[VAL_5]]#0 (%{{.*}}:%{{.*}}:%{{.*}}) shape %{{.*}} : (!fir.box<!fir.array<?xi64>>, i64, i64, index, !fir.shape<1>) -> !fir.box<!fir.array<?xi64>>42// CHECK: fir.do_loop %[[VAL_20:.*]] = {{.*}} {43// CHECK: %[[VAL_21:.*]] = hlfir.designate %[[VAL_18]] (%[[VAL_20]]) : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>44// CHECK: fir.call @logical_to_real(%[[VAL_21]], %{{.*}}) : (!fir.ref<i64>, !fir.logical<4>) -> ()45// CHECK: }46// CHECK: return47// CHECK: }48 49// Test simplified IR for:50//51// ! x = [0,1,2,4] -> [4,2,1,1]52// forall (i=1:3) x(x(i)+1:x(i+1)) = x(4-i)53//54// Verify that the LHS are all computed an saved on a stack before55// any assignment is made.56//57func.func @save_box_in_stack(%arg0: !fir.box<!fir.array<?xi32>>) {58 %c1 = arith.constant 1 : index59 %c1_i32 = arith.constant 1 : i3260 %c4_i64 = arith.constant 4 : i6461 %c3_i64 = arith.constant 3 : i6462 %c1_i64 = arith.constant 1 : i6463 %0:2 = hlfir.declare %arg0 {uniq_name = "x"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)64 hlfir.forall lb {65 hlfir.yield %c1_i64 : i6466 } ub {67 hlfir.yield %c3_i64 : i6468 } (%arg1: i64) {69 hlfir.region_assign {70 %1 = arith.subi %c4_i64, %arg1 : i6471 %2 = hlfir.designate %0#0 (%1) : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>72 %3 = fir.load %2 : !fir.ref<i32>73 hlfir.yield %3 : i3274 } to {75 %1 = hlfir.designate %0#0 (%arg1) : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>76 %2 = fir.load %1 : !fir.ref<i32>77 %3 = arith.addi %2, %c1_i32 : i3278 %4 = arith.addi %arg1, %c1_i64 : i6479 %5 = hlfir.designate %0#0 (%4) : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>80 %6 = fir.load %5 : !fir.ref<i32>81 %7 = arith.subi %6, %3 : i3282 %8 = fir.convert %7 : (i32) -> index83 %9 = fir.shape %8 : (index) -> !fir.shape<1>84 %10 = hlfir.designate %0#0 (%3:%6:%c1) shape %9 : (!fir.box<!fir.array<?xi32>>, i32, i32, index, !fir.shape<1>) -> !fir.box<!fir.array<?xi32>>85 hlfir.yield %10 : !fir.box<!fir.array<?xi32>>86 }87 }88 return89}90// CHECK-LABEL: func.func @save_box_in_stack(91// CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>>) {92// CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>>93// CHECK: %[[VAL_2:.*]] = fir.alloca i6494// CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "x"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)95// CHECK: %[[VAL_30:.*]] = fir.call @_FortranACreateDescriptorStack(%{{.*}}, %{{.*}}) : (!fir.ref<i8>, i32) -> !fir.llvm_ptr<i8>96// CHECK: fir.do_loop {{.*}} {97// CHECK: %[[VAL_48:.*]] = hlfir.designate %[[VAL_9]]#0 {{.*}} : (!fir.box<!fir.array<?xi32>>, i32, i32, index, !fir.shape<1>) -> !fir.box<!fir.array<?xi32>>98// CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>99// CHECK: fir.call @_FortranAPushDescriptor(%[[VAL_30]], %[[VAL_49]]) : (!fir.llvm_ptr<i8>, !fir.box<none>) -> ()100// CHECK: }101// CHECK: fir.store %{{.*}} to %[[VAL_2]] : !fir.ref<i64>102// CHECK: fir.do_loop {{.*}} {103// CHECK: %[[VAL_60:.*]] = fir.load %[[VAL_2]] : !fir.ref<i64>104// CHECK: %[[VAL_61:.*]] = arith.addi %[[VAL_60]], %{{.*}} : i64105// CHECK: fir.store %[[VAL_61]] to %[[VAL_2]] : !fir.ref<i64>106// CHECK: %[[VAL_62:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>107// CHECK: fir.call @_FortranADescriptorAt(%[[VAL_30]], %[[VAL_60]], %[[VAL_62]]) : (!fir.llvm_ptr<i8>, i64, !fir.ref<!fir.box<none>>) -> ()108// CHECK: %[[VAL_64:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>109// CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_64]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>) -> !fir.box<!fir.array<?xi32>>110// CHECK: hlfir.assign %{{.*}} to %[[VAL_65]] : i32, !fir.box<!fir.array<?xi32>>111// CHECK: }112// CHECK: fir.call @_FortranADestroyDescriptorStack(%[[VAL_30]]) : (!fir.llvm_ptr<i8>) -> ()113 114// Test simplified IR for:115//116// integer(8) :: x(*)117// forall (integer::i=1:10) x(x(foo(x, i):bar(x, i))) = x(11-i)118//119// The shape of the vector subscripted designator must be saved at each120// iteration.121//122func.func @test_vector_subscript_overlap(%arg0: !fir.ref<!fir.array<?xi64>>) {123 %c1 = arith.constant 1 : index124 %c10 = arith.constant 10 : index125 %c11 = arith.constant 11 : index126 %0 = fir.undefined index127 %1 = fir.shape %0 : (index) -> !fir.shape<1>128 %2:2 = hlfir.declare %arg0(%1) {uniq_name = "x"} : (!fir.ref<!fir.array<?xi64>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi64>>, !fir.ref<!fir.array<?xi64>>)129 hlfir.forall lb {130 hlfir.yield %c1 : index131 } ub {132 hlfir.yield %c10 : index133 } (%arg1: index) {134 hlfir.region_assign {135 %3 = arith.subi %c11, %arg1 : index136 %4 = hlfir.designate %2#0 (%3) : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>137 %5 = fir.load %4 : !fir.ref<i64>138 hlfir.yield %5 : i64139 } to {140 %3 = fir.call @foo(%2#1, %arg1) : (!fir.ref<!fir.array<?xi64>>, index) -> index141 %4 = fir.call @bar(%2#1, %arg1) : (!fir.ref<!fir.array<?xi64>>, index) -> index142 %5 = arith.subi %4, %3 : index143 %6 = fir.shape %5 : (index) -> !fir.shape<1>144 %7 = hlfir.designate %2#0 (%3:%4:%c1) shape %6 : (!fir.box<!fir.array<?xi64>>, index, index, index, !fir.shape<1>) -> !fir.box<!fir.array<?xi64>>145 hlfir.elemental_addr %6 : !fir.shape<1> {146 ^bb0(%arg2: index):147 %8 = hlfir.designate %7 (%arg2) : (!fir.box<!fir.array<?xi64>>, index) -> !fir.ref<i64>148 %9 = fir.load %8 : !fir.ref<i64>149 %10 = hlfir.designate %2#0 (%9) : (!fir.box<!fir.array<?xi64>>, i64) -> !fir.ref<i64>150 hlfir.yield %10 : !fir.ref<i64>151 }152 }153 }154 return155}156// CHECK-LABEL: func.func @test_vector_subscript_overlap(157// CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xi64>>) {158// CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>>159// CHECK: %[[VAL_2:.*]] = fir.alloca i64160// CHECK: %[[VAL_3:.*]] = fir.alloca !fir.box<!fir.ptr<i64>>161// CHECK: %[[VAL_4:.*]] = fir.alloca i64162// CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_0]](%{{.*}}) {uniq_name = "x"} : (!fir.ref<!fir.array<?xi64>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xi64>>, !fir.ref<!fir.array<?xi64>>)163// CHECK: %[[VAL_30:.*]] = fir.call @_FortranACreateDescriptorStack(%{{.*}}, %{{.*}}) : (!fir.ref<i8>, i32) -> !fir.llvm_ptr<i8>164// CHECK: %[[VAL_37:.*]] = fir.call @_FortranACreateDescriptorStack(%{{.*}}, %{{.*}}) : (!fir.ref<i8>, i32) -> !fir.llvm_ptr<i8>165// CHECK: fir.do_loop {{.*}} {166// CHECK: %[[VAL_45:.*]] = fir.call @foo167// CHECK: %[[VAL_46:.*]] = fir.call @bar168// CHECK: %[[VAL_47:.*]] = arith.subi %[[VAL_46]], %[[VAL_45]] : index169// CHECK: %[[VAL_48:.*]] = fir.shape %[[VAL_47]] : (index) -> !fir.shape<1>170// CHECK: %[[VAL_51:.*]] = fir.zero_bits !fir.ref<!fir.array<?xi32>>171// CHECK: %[[VAL_52:.*]] = fir.embox %[[VAL_51]](%[[VAL_48]]) : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xi32>>172// CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_52]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>173// Save the vector subscripted designator shape.174// CHECK: fir.call @_FortranAPushDescriptor({{.*}}, {{.*}}) : (!fir.llvm_ptr<i8>, !fir.box<none>) -> ()175// CHECK: fir.do_loop {{.*}} {176// CHECK: %[[VAL_60:.*]] = hlfir.designate %[[VAL_11]]#0 (%{{.*}}) : (!fir.box<!fir.array<?xi64>>, i64) -> !fir.ref<i64>177// CHECK: %[[VAL_61:.*]] = fir.embox %[[VAL_60]] : (!fir.ref<i64>) -> !fir.box<i64>178// CHECK: %[[VAL_62:.*]] = fir.convert %[[VAL_61]] : (!fir.box<i64>) -> !fir.box<none>179// Save the vector subscripted designator element address.180// CHECK: fir.call @_FortranAPushDescriptor(%[[VAL_30]], %[[VAL_62]]) : (!fir.llvm_ptr<i8>, !fir.box<none>) -> ()181// CHECK: }182// CHECK: }183// CHECK: fir.store %{{.*}} to %[[VAL_4]] : !fir.ref<i64>184// CHECK: fir.store %{{.*}} to %[[VAL_2]] : !fir.ref<i64>185// CHECK: fir.do_loop {{.*}} {186// CHECK: %[[VAL_69:.*]] = fir.load %{{.*}} : !fir.ref<i64>187// CHECK: %[[VAL_70:.*]] = fir.load %[[VAL_2]] : !fir.ref<i64>188// CHECK: %[[VAL_71:.*]] = arith.addi %[[VAL_70]], %{{.*}} : i64189// CHECK: fir.store %[[VAL_71]] to %[[VAL_2]] : !fir.ref<i64>190// CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>191// Fetch the vector subscripted designator shape to create the elemental loop.192// CHECK: fir.call @_FortranADescriptorAt(%[[VAL_37]], %[[VAL_70]], %[[VAL_72]]) : (!fir.llvm_ptr<i8>, i64, !fir.ref<!fir.box<none>>) -> ()193// CHECK: %[[VAL_74:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>194// CHECK: %[[VAL_75:.*]] = fir.convert %[[VAL_74]] : (!fir.box<!fir.ptr<!fir.array<?xi32>>>) -> !fir.box<!fir.array<?xi32>>195// CHECK: %[[VAL_76:.*]] = arith.constant 0 : index196// CHECK: %[[VAL_77:.*]]:3 = fir.box_dims %[[VAL_75]], %[[VAL_76]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)197// CHECK: %[[VAL_79:.*]] = arith.constant 1 : index198// CHECK: fir.do_loop %[[VAL_80:.*]] = %[[VAL_79]] to %[[VAL_77]]#1 step %[[VAL_79]] {199// CHECK: %[[VAL_81:.*]] = fir.load %[[VAL_4]] : !fir.ref<i64>200// CHECK: %[[VAL_82:.*]] = arith.addi %[[VAL_81]], %{{.*}} : i64201// CHECK: fir.store %[[VAL_82]] to %[[VAL_4]] : !fir.ref<i64>202// CHECK: %[[VAL_83:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<!fir.box<!fir.ptr<i64>>>) -> !fir.ref<!fir.box<none>>203// Fetch the vector subscripted designator element address.204// CHECK: fir.call @_FortranADescriptorAt(%[[VAL_30]], %[[VAL_81]], %[[VAL_83]]) : (!fir.llvm_ptr<i8>, i64, !fir.ref<!fir.box<none>>) -> ()205// CHECK: %[[VAL_85:.*]] = fir.load %[[VAL_3]] : !fir.ref<!fir.box<!fir.ptr<i64>>>206// CHECK: %[[VAL_86:.*]] = fir.box_addr %[[VAL_85]] : (!fir.box<!fir.ptr<i64>>) -> !fir.ptr<i64>207// CHECK: %[[VAL_87:.*]] = fir.convert %[[VAL_86]] : (!fir.ptr<i64>) -> !fir.ref<i64>208// CHECK: hlfir.assign %{{.*}} to %[[VAL_87]] : i64, !fir.ref<i64>209// CHECK: }210// CHECK: }211// CHECK: fir.call @_FortranADestroyDescriptorStack(%[[VAL_30]]) : (!fir.llvm_ptr<i8>) -> ()212// CHECK: fir.call @_FortranADestroyDescriptorStack(%[[VAL_37]]) : (!fir.llvm_ptr<i8>) -> ()213 214func.func private @integer_to_real(!fir.ref<i64>, !fir.logical<4>)215func.func private @foo(!fir.ref<!fir.array<?xi64>>, index) -> index216func.func private @bar(!fir.ref<!fir.array<?xi64>>, index) -> index217