brintos / llvm-project-archived public Read only

1// RUN: fir-opt --split-input-file --cfg-conversion --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s2 3func.func @_QPsb1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {4  %c1_i64 = arith.constant 1 : i645  %c1_i32 = arith.constant 1 : i326  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}7  omp.parallel  {8    %1 = fir.alloca i32 {adapt.valuebyref, pinned}9    %2 = fir.load %arg0 : !fir.ref<i32>10    omp.wsloop nowait {11      omp.loop_nest (%arg2) : i32 = (%c1_i32) to (%2) inclusive step (%c1_i32)  {12        fir.store %arg2 to %1 : !fir.ref<i32>13        %3 = fir.load %1 : !fir.ref<i32>14        %4 = fir.convert %3 : (i32) -> i6415        %5 = arith.subi %4, %c1_i64 : i6416        %6 = fir.coordinate_of %arg1, %5 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>17        fir.store %3 to %6 : !fir.ref<i32>18        omp.yield19      }20    }21    omp.terminator22  }23  return24}25 26// CHECK-LABEL:  _QPsb127// CHECK-SAME: %[[N_REF:.*]]: !llvm.ptr {fir.bindc_name = "n"}, %[[ARR_REF:.*]]: !llvm.ptr {fir.bindc_name = "arr"}) {28// CHECK:    %[[ONE_0:.*]] = llvm.mlir.constant(1 : i64) : i6429// CHECK:    %[[ONE_1:.*]] = llvm.mlir.constant(1 : i64) : i6430// CHECK:    %[[ONE_2:.*]] = llvm.mlir.constant(1 : i32) : i3231// CHECK: omp.parallel   {32// CHECK:      %[[ONE_3:.*]] = llvm.mlir.constant(1 : i64) : i6433// CHECK:      %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {pinned} : (i64) -> !llvm.ptr34// CHECK:      %[[N:.*]] = llvm.load %[[N_REF]] : !llvm.ptr -> i3235// CHECK: omp.wsloop nowait36// CHECK-NEXT: omp.loop_nest (%[[I:.*]]) : i32 = (%[[ONE_2]]) to (%[[N]]) inclusive step (%[[ONE_2]]) {37// CHECK:   llvm.store %[[I]], %[[I_VAR]] : i32, !llvm.ptr38// CHECK:   %[[I1:.*]] = llvm.load %[[I_VAR]] : !llvm.ptr -> i3239// CHECK:   %[[I1_EXT:.*]] = llvm.sext %[[I1]] : i32 to i6440// CHECK:   %[[I_CSTYLE:.*]] = llvm.sub %[[I1_EXT]], %[[ONE_1]]  : i6441// CHECK:   %[[ARR_I_REF:.*]] = llvm.getelementptr %[[ARR_REF]][%[[I_CSTYLE]]] : (!llvm.ptr, i64) -> !llvm.ptr42// CHECK:   llvm.store %[[I1]], %[[ARR_I_REF]] : i32, !llvm.ptr43// CHECK: omp.yield44// CHECK: }45// CHECK: }46// CHECK: omp.terminator47// CHECK: }48// CHECK: llvm.return49// CHECK: }50 51// -----52 53func.func @_QPsb2(%arg0: !fir.ref<i32> {fir.bindc_name = "x"}, %arg1: !fir.ref<i32> {fir.bindc_name = "n"}) {54  omp.parallel  {55    omp.master  {56      %0 = fir.load %arg1 : !fir.ref<i32>57      fir.store %0 to %arg0 : !fir.ref<i32>58      omp.terminator59    }60    omp.terminator61  }62  return63}64 65// CHECK-LABEL: _QPsb266// CHECK-SAME: %[[X_REF:.*]]: !llvm.ptr {fir.bindc_name = "x"}, %[[N_REF:.*]]: !llvm.ptr {fir.bindc_name = "n"}) {67// CHECK: omp.parallel   {68// CHECK:   omp.master {69// CHECK:     %[[N:.*]] = llvm.load %[[N_REF]] : !llvm.ptr -> i3270// CHECK:     llvm.store %[[N]], %[[X_REF]] : i32, !llvm.ptr71// CHECK:     omp.terminator72// CHECK:   }73// CHECK:   omp.terminator74// CHECK: }75// CHECK: llvm.return76// CHECK: }77 78// -----79 80func.func @_QPsb(%arr: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {81  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}82  omp.parallel   {83    %c1 = arith.constant 1 : i3284    %c50 = arith.constant 50 : i3285    omp.wsloop {86      omp.loop_nest (%indx) : i32 = (%c1) to (%c50) inclusive step (%c1) {87        %1 = fir.convert %indx : (i32) -> i6488        %c1_i64 = arith.constant 1 : i6489        %2 = arith.subi %1, %c1_i64 : i6490        %3 = fir.coordinate_of %arr, %2 : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>91        fir.store %indx to %3 : !fir.ref<i32>92        omp.yield93      }94    }95    omp.terminator96  }97  return98}99 100// Check only for the structure of the OpenMP portion and the feasibility of the conversion101// CHECK-LABEL: @_QPsb102// CHECK-SAME: %{{.*}}: !llvm.ptr {fir.bindc_name = "arr"}103// CHECK:    omp.parallel   {104// CHECK:      %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32105// CHECK:      %[[C50:.*]] = llvm.mlir.constant(50 : i32) : i32106// CHECK:      omp.wsloop {107// CHECK-NEXT:   omp.loop_nest (%[[INDX:.*]]) : i32 = (%[[C1]]) to (%[[C50]]) inclusive step (%[[C1]]) {108// CHECK:          llvm.store %[[INDX]], %{{.*}} : i32, !llvm.ptr109// CHECK:          omp.yield110// CHECK:      omp.terminator111// CHECK:    llvm.return112 113// -----114 115func.func private @foo()116func.func private @bar()117 118func.func @sections_no_data() {119  omp.sections {120    omp.section {121      fir.call @foo() : () -> ()122      omp.terminator123    }124    omp.section {125      fir.call @bar() : () -> ()126      omp.terminator127    }128    omp.terminator129  }130  return131}132 133// CHECK-LABEL: llvm.func @sections_no_data134// CHECK: omp.sections {135// CHECK:   omp.section {136// CHECK:     llvm.call @foo() : () -> ()137// CHECK:     omp.terminator138// CHECK:   }139// CHECK:   omp.section {140// CHECK:     llvm.call @bar() : () -> ()141// CHECK:     omp.terminator142// CHECK:   }143// CHECK:   omp.terminator144// CHECK: }145 146// -----147 148func.func private @foo(!fir.ref<i32>)149func.func private @bar(!fir.ref<i32>, !fir.ref<i32>)150 151func.func @sections_data_without_clauses(%arg0: !fir.ref<i32> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "b"}) {152  omp.sections {153    omp.section {154      fir.call @foo(%arg0) : (!fir.ref<i32>) -> ()155      omp.terminator156    }157    omp.section {158      fir.call @bar(%arg0, %arg1) : (!fir.ref<i32>, !fir.ref<i32>) -> ()159      omp.terminator160    }161    omp.terminator162  }163  return164}165 166// CHECK-LABEL: llvm.func @sections_data_without_clauses167// CHECK-SAME:            (%[[ARG0:.+]]: !llvm.ptr {fir.bindc_name = "a"}, %[[ARG1:.+]]: !llvm.ptr {fir.bindc_name = "b"})168// CHECK: omp.sections {169// CHECK:   omp.section {170// CHECK:     llvm.call @foo(%arg0) : (!llvm.ptr) -> ()171// CHECK:     omp.terminator172// CHECK:   }173// CHECK:   omp.section {174// CHECK:     llvm.call @bar(%[[ARG0]], %[[ARG1]]) : (!llvm.ptr, !llvm.ptr) -> ()175// CHECK:     omp.terminator176// CHECK:   }177// CHECK:   omp.terminator178// CHECK: }179 180// -----181 182func.func @_QPsimd1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {183  %c1_i64 = arith.constant 1 : i64184  %c1_i32 = arith.constant 1 : i32185  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}186  omp.parallel  {187    %1 = fir.alloca i32 {adapt.valuebyref, pinned}188    %2 = fir.load %arg0 : !fir.ref<i32>189    omp.simd {190      omp.loop_nest (%arg2) : i32 = (%c1_i32) to (%2) step (%c1_i32) {191        fir.store %arg2 to %1 : !fir.ref<i32>192        %3 = fir.load %1 : !fir.ref<i32>193        %4 = fir.convert %3 : (i32) -> i64194        %5 = arith.subi %4, %c1_i64 : i64195        %6 = fir.coordinate_of %arg1, %5 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>196        fir.store %3 to %6 : !fir.ref<i32>197        omp.yield198      }199    }200    omp.terminator201  }202  return203}204 205// CHECK-LABEL:  _QPsimd1206// CHECK-SAME: %[[N_REF:.*]]: !llvm.ptr {fir.bindc_name = "n"}, %[[ARR_REF:.*]]: !llvm.ptr {fir.bindc_name = "arr"}) {207// CHECK:    %[[ONE_0:.*]] = llvm.mlir.constant(1 : i64) : i64208// CHECK:    %[[ONE_1:.*]] = llvm.mlir.constant(1 : i64) : i64209// CHECK:    %[[ONE_2:.*]] = llvm.mlir.constant(1 : i32) : i32210// CHECK: omp.parallel   {211// CHECK:      %[[ONE_3:.*]] = llvm.mlir.constant(1 : i64) : i64212// CHECK:      %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {pinned} : (i64) -> !llvm.ptr213// CHECK:      %[[N:.*]] = llvm.load %[[N_REF]] : !llvm.ptr -> i32214// CHECK: omp.simd {215// CHECK-NEXT: omp.loop_nest (%[[I:.*]]) : i32 = (%[[ONE_2]]) to (%[[N]]) step (%[[ONE_2]]) {216// CHECK:   llvm.store %[[I]], %[[I_VAR]] : i32, !llvm.ptr217// CHECK:   %[[I1:.*]] = llvm.load %[[I_VAR]] : !llvm.ptr -> i32218// CHECK:   %[[I1_EXT:.*]] = llvm.sext %[[I1]] : i32 to i64219// CHECK:   %[[I_CSTYLE:.*]] = llvm.sub %[[I1_EXT]], %[[ONE_1]]  : i64220// CHECK:   %[[ARR_I_REF:.*]] = llvm.getelementptr %[[ARR_REF]][%[[I_CSTYLE]]] : (!llvm.ptr, i64) -> !llvm.ptr221// CHECK:   llvm.store %[[I1]], %[[ARR_I_REF]] : i32, !llvm.ptr222// CHECK: omp.yield223// CHECK: }224// CHECK: }225// CHECK: omp.terminator226// CHECK: }227// CHECK: llvm.return228// CHECK: }229 230// -----231 232func.func @_QPomp_target_data() {233  %c1024 = arith.constant 1024 : index234  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_dataEa"}235  %c1024_0 = arith.constant 1024 : index236  %1 = fir.alloca !fir.array<1024xi32> {bindc_name = "b", uniq_name = "_QFomp_target_dataEb"}237  %c1024_1 = arith.constant 1024 : index238  %2 = fir.alloca !fir.array<1024xi32> {bindc_name = "c", uniq_name = "_QFomp_target_dataEc"}239  %c1024_2 = arith.constant 1024 : index240  %3 = fir.alloca !fir.array<1024xi32> {bindc_name = "d", uniq_name = "_QFomp_target_dataEd"}241  %c1 = arith.constant 1 : index242  %c0 = arith.constant 0 : index243  %4 = arith.subi %c1024, %c1 : index244  %5 = omp.map.bounds   lower_bound(%c0 : index) upper_bound(%4 : index) extent(%c1024 : index) stride(%c1 : index) start_idx(%c1 : index)245  %6 = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(to) capture(ByRef) bounds(%5) -> !fir.ref<!fir.array<1024xi32>> {name = "a"}246  %c1_3 = arith.constant 1 : index247  %c0_4 = arith.constant 0 : index248  %7 = arith.subi %c1024_0, %c1_3 : index249  %8 = omp.map.bounds   lower_bound(%c0_4 : index) upper_bound(%7 : index) extent(%c1024_0 : index) stride(%c1_3 : index) start_idx(%c1_3 : index)250  %9 = omp.map.info var_ptr(%1 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(to) capture(ByRef) bounds(%8) -> !fir.ref<!fir.array<1024xi32>> {name = "b"}251  %c1_5 = arith.constant 1 : index252  %c0_6 = arith.constant 0 : index253  %10 = arith.subi %c1024_1, %c1_5 : index254  %11 = omp.map.bounds   lower_bound(%c0_6 : index) upper_bound(%10 : index) extent(%c1024_1 : index) stride(%c1_5 : index) start_idx(%c1_5 : index)255  %12 = omp.map.info var_ptr(%2 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(always, storage) capture(ByRef) bounds(%11) -> !fir.ref<!fir.array<1024xi32>> {name = "c"}256  omp.target_enter_data   map_entries(%6, %9, %12 : !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>)257  %c1_7 = arith.constant 1 : index258  %c0_8 = arith.constant 0 : index259  %13 = arith.subi %c1024, %c1_7 : index260  %14 = omp.map.bounds   lower_bound(%c0_8 : index) upper_bound(%13 : index) extent(%c1024 : index) stride(%c1_7 : index) start_idx(%c1_7 : index)261  %15 = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(from) capture(ByRef) bounds(%14) -> !fir.ref<!fir.array<1024xi32>> {name = "a"}262  %c1_9 = arith.constant 1 : index263  %c0_10 = arith.constant 0 : index264  %16 = arith.subi %c1024_0, %c1_9 : index265  %17 = omp.map.bounds   lower_bound(%c0_10 : index) upper_bound(%16 : index) extent(%c1024_0 : index) stride(%c1_9 : index) start_idx(%c1_9 : index)266  %18 = omp.map.info var_ptr(%1 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(from) capture(ByRef) bounds(%17) -> !fir.ref<!fir.array<1024xi32>> {name = "b"}267  %c1_11 = arith.constant 1 : index268  %c0_12 = arith.constant 0 : index269  %19 = arith.subi %c1024_1, %c1_11 : index270  %20 = omp.map.bounds   lower_bound(%c0_12 : index) upper_bound(%19 : index) extent(%c1024_1 : index) stride(%c1_11 : index) start_idx(%c1_11 : index)271  %21 = omp.map.info var_ptr(%2 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(storage) capture(ByRef) bounds(%20) -> !fir.ref<!fir.array<1024xi32>> {name = "c"}272  %c1_13 = arith.constant 1 : index273  %c0_14 = arith.constant 0 : index274  %22 = arith.subi %c1024_2, %c1_13 : index275  %23 = omp.map.bounds   lower_bound(%c0_14 : index) upper_bound(%22 : index) extent(%c1024_2 : index) stride(%c1_13 : index) start_idx(%c1_13 : index)276  %24 = omp.map.info var_ptr(%3 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(always, delete) capture(ByRef) bounds(%23) -> !fir.ref<!fir.array<1024xi32>> {name = "d"}277  omp.target_exit_data   map_entries(%15, %18, %21, %24 : !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>)278  return279}280 281// CHECK-LABEL:   llvm.func @_QPomp_target_data() {282// CHECK:           %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64283// CHECK:           %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.array<1024 x i32> {bindc_name = "d"} : (i64) -> !llvm.ptr284// CHECK:           %[[VAL_3:.*]] = llvm.mlir.constant(1 : i64) : i64285// CHECK:           %[[VAL_4:.*]] = llvm.alloca %[[VAL_3]] x !llvm.array<1024 x i32> {bindc_name = "c"} : (i64) -> !llvm.ptr286// CHECK:           %[[VAL_5:.*]] = llvm.mlir.constant(1 : i64) : i64287// CHECK:           %[[VAL_6:.*]] = llvm.alloca %[[VAL_5]] x !llvm.array<1024 x i32> {bindc_name = "b"} : (i64) -> !llvm.ptr288// CHECK:           %[[VAL_7:.*]] = llvm.mlir.constant(1 : i64) : i64289// CHECK:           %[[VAL_8:.*]] = llvm.alloca %[[VAL_7]] x !llvm.array<1024 x i32> {bindc_name = "a"} : (i64) -> !llvm.ptr290// CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(1024 : index) : i64291// CHECK:           %[[VAL_9:.*]] = llvm.mlir.constant(1024 : index) : i64292// CHECK:           %[[VAL_10:.*]] = llvm.mlir.constant(1024 : index) : i64293// CHECK:           %[[VAL_11:.*]] = llvm.mlir.constant(1024 : index) : i64294// CHECK:           %[[VAL_12:.*]] = llvm.mlir.constant(1 : index) : i64295// CHECK:           %[[VAL_13:.*]] = llvm.mlir.constant(0 : index) : i64296// CHECK:           %[[VAL_14:.*]] = llvm.mlir.constant(1023 : index) : i64297// CHECK:           %[[VAL_15:.*]] = omp.map.bounds lower_bound(%[[VAL_13]] : i64) upper_bound(%[[VAL_14]] : i64) extent(%[[VAL_0]] : i64) stride(%[[VAL_12]] : i64) start_idx(%[[VAL_12]] : i64)298// CHECK:           %[[VAL_16:.*]] = omp.map.info var_ptr(%[[VAL_8]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(to) capture(ByRef) bounds(%[[VAL_15]]) -> !llvm.ptr {name = "a"}299// CHECK:           %[[VAL_17:.*]] = llvm.mlir.constant(1 : index) : i64300// CHECK:           %[[VAL_18:.*]] = llvm.mlir.constant(0 : index) : i64301// CHECK:           %[[VAL_19:.*]] = llvm.mlir.constant(1023 : index) : i64302// CHECK:           %[[VAL_20:.*]] = omp.map.bounds lower_bound(%[[VAL_18]] : i64) upper_bound(%[[VAL_19]] : i64) extent(%[[VAL_9]] : i64) stride(%[[VAL_17]] : i64) start_idx(%[[VAL_17]] : i64)303// CHECK:           %[[VAL_21:.*]] = omp.map.info var_ptr(%[[VAL_6]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(to) capture(ByRef) bounds(%[[VAL_20]]) -> !llvm.ptr {name = "b"}304// CHECK:           %[[VAL_22:.*]] = llvm.mlir.constant(1 : index) : i64305// CHECK:           %[[VAL_23:.*]] = llvm.mlir.constant(0 : index) : i64306// CHECK:           %[[VAL_24:.*]] = llvm.mlir.constant(1023 : index) : i64307// CHECK:           %[[VAL_25:.*]] = omp.map.bounds lower_bound(%[[VAL_23]] : i64) upper_bound(%[[VAL_24]] : i64) extent(%[[VAL_10]] : i64) stride(%[[VAL_22]] : i64) start_idx(%[[VAL_22]] : i64)308// CHECK:           %[[VAL_26:.*]] = omp.map.info var_ptr(%[[VAL_4]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(always, storage) capture(ByRef) bounds(%[[VAL_25]]) -> !llvm.ptr {name = "c"}309// CHECK:           omp.target_enter_data map_entries(%[[VAL_16]], %[[VAL_21]], %[[VAL_26]] : !llvm.ptr, !llvm.ptr, !llvm.ptr)310// CHECK:           %[[VAL_27:.*]] = llvm.mlir.constant(1 : index) : i64311// CHECK:           %[[VAL_28:.*]] = llvm.mlir.constant(0 : index) : i64312// CHECK:           %[[VAL_29:.*]] = llvm.mlir.constant(1023 : index) : i64313// CHECK:           %[[VAL_30:.*]] = omp.map.bounds lower_bound(%[[VAL_28]] : i64) upper_bound(%[[VAL_29]] : i64) extent(%[[VAL_0]] : i64) stride(%[[VAL_27]] : i64) start_idx(%[[VAL_27]] : i64)314// CHECK:           %[[VAL_31:.*]] = omp.map.info var_ptr(%[[VAL_8]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(from) capture(ByRef) bounds(%[[VAL_30]]) -> !llvm.ptr {name = "a"}315// CHECK:           %[[VAL_32:.*]] = llvm.mlir.constant(1 : index) : i64316// CHECK:           %[[VAL_33:.*]] = llvm.mlir.constant(0 : index) : i64317// CHECK:           %[[VAL_34:.*]] = llvm.mlir.constant(1023 : index) : i64318// CHECK:           %[[VAL_35:.*]] = omp.map.bounds lower_bound(%[[VAL_33]] : i64) upper_bound(%[[VAL_34]] : i64) extent(%[[VAL_9]] : i64) stride(%[[VAL_32]] : i64) start_idx(%[[VAL_32]] : i64)319// CHECK:           %[[VAL_36:.*]] = omp.map.info var_ptr(%[[VAL_6]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(from) capture(ByRef) bounds(%[[VAL_35]]) -> !llvm.ptr {name = "b"}320// CHECK:           %[[VAL_37:.*]] = llvm.mlir.constant(1 : index) : i64321// CHECK:           %[[VAL_38:.*]] = llvm.mlir.constant(0 : index) : i64322// CHECK:           %[[VAL_39:.*]] = llvm.mlir.constant(1023 : index) : i64323// CHECK:           %[[VAL_40:.*]] = omp.map.bounds lower_bound(%[[VAL_38]] : i64) upper_bound(%[[VAL_39]] : i64) extent(%[[VAL_10]] : i64) stride(%[[VAL_37]] : i64) start_idx(%[[VAL_37]] : i64)324// CHECK:           %[[VAL_41:.*]] = omp.map.info var_ptr(%[[VAL_4]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(storage) capture(ByRef) bounds(%[[VAL_40]]) -> !llvm.ptr {name = "c"}325// CHECK:           %[[VAL_42:.*]] = llvm.mlir.constant(1 : index) : i64326// CHECK:           %[[VAL_43:.*]] = llvm.mlir.constant(0 : index) : i64327// CHECK:           %[[VAL_44:.*]] = llvm.mlir.constant(1023 : index) : i64328// CHECK:           %[[VAL_45:.*]] = omp.map.bounds lower_bound(%[[VAL_43]] : i64) upper_bound(%[[VAL_44]] : i64) extent(%[[VAL_11]] : i64) stride(%[[VAL_42]] : i64) start_idx(%[[VAL_42]] : i64)329// CHECK:           %[[VAL_46:.*]] = omp.map.info var_ptr(%[[VAL_2]] : !llvm.ptr, !llvm.array<1024 x i32>) map_clauses(always, delete) capture(ByRef) bounds(%[[VAL_45]]) -> !llvm.ptr {name = "d"}330// CHECK:           omp.target_exit_data map_entries(%[[VAL_31]], %[[VAL_36]], %[[VAL_41]], %[[VAL_46]] : !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr)331// CHECK:           llvm.return332// CHECK:         }333 334// -----335 336func.func @_QPopenmp_target_data_region() {337  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFopenmp_target_data_regionEa"}338  %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFopenmp_target_data_regionEi"}339  %c1024 = arith.constant 1024 : index340  %c3 = arith.constant 1 : index341  %c0 = arith.constant 0 : index342  %c2 = arith.subi %c1024, %c3 : index343  %bound = omp.map.bounds   lower_bound(%c0 : index) upper_bound(%c2 : index) extent(%c1024 : index) stride(%c3 : index) start_idx(%c3 : index)344  %entry = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<1024xi32>>, !fir.array<1024xi32>)   map_clauses(tofrom) capture(ByRef) bounds(%bound) -> !fir.ref<!fir.array<1024xi32>> {name = "a"}345  omp.target_data   map_entries(%entry : !fir.ref<!fir.array<1024xi32>>) {346    %c1_i32 = arith.constant 1 : i32347    %2 = fir.convert %c1_i32 : (i32) -> index348    %c1024_i32 = arith.constant 1024 : i32349    %3 = fir.convert %c1024_i32 : (i32) -> index350    %c1 = arith.constant 1 : index351    %4 = fir.convert %2 : (index) -> i32352    %5 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (i32) {353      fir.store %arg1 to %1 : !fir.ref<i32>354      %6 = fir.load %1 : !fir.ref<i32>355      %7 = fir.load %1 : !fir.ref<i32>356      %8 = fir.convert %7 : (i32) -> i64357      %c1_i64 = arith.constant 1 : i64358      %9 = arith.subi %8, %c1_i64 : i64359      %10 = fir.coordinate_of %0, %9 : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>360      fir.store %6 to %10 : !fir.ref<i32>361      %12 = fir.convert %c1 : (index) -> i32362      %13 = fir.load %1 : !fir.ref<i32>363      %14 = arith.addi %13, %12 overflow<nsw> : i32364      fir.result %14 : i32365    }366    fir.store %5 to %1 : !fir.ref<i32>367    omp.terminator368  }369  return370}371 372// CHECK-LABEL:   llvm.func @_QPopenmp_target_data_region() {373// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(1 : i64) : i64374// CHECK:           %[[VAL_3:.*]] = llvm.alloca %[[VAL_2]] x i32 {bindc_name = "i"} : (i64) -> !llvm.ptr375// CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(1 : i64) : i64376// CHECK:           %[[VAL_1:.*]] = llvm.alloca %[[VAL_0]] x !llvm.array<1024 x i32> {bindc_name = "a"} : (i64) -> !llvm.ptr377// CHECK:           %[[VAL_MAX:.*]] = llvm.mlir.constant(1024 : index) : i64378// CHECK:           %[[VAL_ONE:.*]] = llvm.mlir.constant(1 : index) : i64379// CHECK:           %[[VAL_ZERO:.*]] = llvm.mlir.constant(0 : index) : i64380// CHECK:           %[[VAL_UPPER:.*]] = llvm.mlir.constant(1023 : index) : i64381// CHECK:           %[[VAL_BOUNDS:.*]] = omp.map.bounds   lower_bound(%[[VAL_ZERO]] : i64) upper_bound(%[[VAL_UPPER]] : i64) extent(%[[VAL_MAX]] : i64) stride(%[[VAL_ONE]] : i64) start_idx(%[[VAL_ONE]] : i64)382// CHECK:           %[[VAL_MAP:.*]] = omp.map.info var_ptr(%[[VAL_1]] : !llvm.ptr, !llvm.array<1024 x i32>)  map_clauses(tofrom) capture(ByRef) bounds(%[[VAL_BOUNDS]]) -> !llvm.ptr {name = "a"}383// CHECK:           omp.target_data   map_entries(%[[VAL_MAP]] : !llvm.ptr) {384// CHECK:             %[[VAL_4:.*]] = llvm.mlir.constant(1 : i32) : i32385// CHECK:             %[[VAL_5:.*]] = llvm.sext %[[VAL_4]] : i32 to i64386// CHECK:             %[[VAL_6:.*]] = llvm.mlir.constant(1024 : i32) : i32387// CHECK:             %[[VAL_7:.*]] = llvm.sext %[[VAL_6]] : i32 to i64388// CHECK:             %[[VAL_8:.*]] = llvm.mlir.constant(1 : index) : i64389// CHECK:             %[[VAL_9:.*]] = llvm.trunc %[[VAL_5]] : i64 to i32390// CHECK:             %[[VAL_10:.*]] = llvm.sub %[[VAL_7]], %[[VAL_5]]  : i64391// CHECK:             %[[VAL_11:.*]] = llvm.add %[[VAL_10]], %[[VAL_8]]  : i64392// CHECK:             llvm.br ^bb1(%[[VAL_5]], %[[VAL_9]], %[[VAL_11]] : i64, i32, i64)393// CHECK:           ^bb1(%[[VAL_12:.*]]: i64, %[[VAL_13:.*]]: i32, %[[VAL_14:.*]]: i64):394// CHECK:             %[[VAL_15:.*]] = llvm.mlir.constant(0 : index) : i64395// CHECK:             %[[VAL_16:.*]] = llvm.icmp "sgt" %[[VAL_14]], %[[VAL_15]] : i64396// CHECK:             llvm.cond_br %[[VAL_16]], ^bb2, ^bb3397// CHECK:           ^bb2:398// CHECK:             llvm.store %[[VAL_13]], %[[VAL_3]] : i32, !llvm.ptr399// CHECK:             %[[VAL_17:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i32400// CHECK:             %[[VAL_18:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i32401// CHECK:             %[[VAL_19:.*]] = llvm.sext %[[VAL_18]] : i32 to i64402// CHECK:             %[[VAL_20:.*]] = llvm.mlir.constant(1 : i64) : i64403// CHECK:             %[[VAL_21:.*]] = llvm.sub %[[VAL_19]], %[[VAL_20]]  : i64404// CHECK:             %[[VAL_22:.*]] = llvm.getelementptr %[[VAL_1]][0, %[[VAL_21]]] : (!llvm.ptr, i64) -> !llvm.ptr405// CHECK:             llvm.store %[[VAL_17]], %[[VAL_22]] : i32, !llvm.ptr406// CHECK:             %[[VAL_24:.*]] = llvm.trunc %[[VAL_8]] : i64 to i32407// CHECK:             %[[VAL_25:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr -> i32408// CHECK:             %[[VAL_26:.*]] = llvm.add %[[VAL_25]], %[[VAL_24]] overflow<nsw> : i32409// CHECK:             %[[VAL_27:.*]] = llvm.add %[[VAL_12]], %[[VAL_8]] overflow<nsw> : i64410// CHECK:             %[[VAL_28:.*]] = llvm.mlir.constant(1 : index) : i64411// CHECK:             %[[VAL_29:.*]] = llvm.sub %[[VAL_14]], %[[VAL_28]]  : i64412// CHECK:             llvm.br ^bb1(%[[VAL_27]], %[[VAL_26]], %[[VAL_29]] : i64, i32, i64)413// CHECK:           ^bb3:414// CHECK:             llvm.store %[[VAL_13]], %[[VAL_3]] : i32, !llvm.ptr415// CHECK:             omp.terminator416// CHECK:           }417// CHECK:           llvm.return418// CHECK:         }419 420// -----421 422func.func @_QPomp_target_data_empty() {423  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_data_emptyEa"}424  %1 = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<1024xi32>>, !fir.ref<!fir.array<1024xi32>>) map_clauses(return_param) capture(ByRef) -> !fir.ref<!fir.array<1024xi32>> {name = ""}425  omp.target_data use_device_addr(%1 -> %arg0 : !fir.ref<!fir.array<1024xi32>>) {426    omp.terminator427  }428  return429}430 431// CHECK-LABEL:   llvm.func @_QPomp_target_data_empty432// CHECK: omp.target_data   use_device_addr(%{{.*}} -> %{{.*}} : !llvm.ptr) {433// CHECK: }434 435// -----436 437func.func @_QPomp_target() {438  %c512 = arith.constant 512 : index439  %0 = fir.alloca !fir.array<512xi32> {bindc_name = "a", uniq_name = "_QFomp_targetEa"}440  %c64_i32 = arith.constant 64 : i32441  %c1 = arith.constant 1 : index442  %c0 = arith.constant 0 : index443  %1 = arith.subi %c512, %c1 : index444  %2 = omp.map.bounds   lower_bound(%c0 : index) upper_bound(%1 : index) extent(%c512 : index) stride(%c1 : index) start_idx(%c1 : index)445  %3 = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<512xi32>>, !fir.array<512xi32>)   map_clauses(tofrom) capture(ByRef) bounds(%2) -> !fir.ref<!fir.array<512xi32>> {name = "a"}446  omp.target   thread_limit(%c64_i32 : i32) map_entries(%3 -> %arg0 : !fir.ref<!fir.array<512xi32>>) {447    %c10_i32 = arith.constant 10 : i32448    %c1_i64 = arith.constant 1 : i64449    %c1_i64_0 = arith.constant 1 : i64450    %4 = arith.subi %c1_i64, %c1_i64_0 : i64451    %5 = fir.coordinate_of %arg0, %4 : (!fir.ref<!fir.array<512xi32>>, i64) -> !fir.ref<i32>452    fir.store %c10_i32 to %5 : !fir.ref<i32>453    omp.terminator454  }455  return456}457 458// CHECK-LABEL:   llvm.func @_QPomp_target() {459// CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(1 : i64) : i64460// CHECK:           %[[VAL_1:.*]] = llvm.alloca %[[VAL_0]] x !llvm.array<512 x i32> {bindc_name = "a"} : (i64) -> !llvm.ptr461// CHECK:           %[[EXTENT:.*]] = llvm.mlir.constant(512 : index) : i64462// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(64 : i32) : i32463// CHECK:           %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64464// CHECK:           %[[LOWER:.*]] = llvm.mlir.constant(0 : index) : i64465// CHECK:           %[[UPPER:.*]] = llvm.mlir.constant(511 : index) : i64466// CHECK:           %[[BOUNDS:.*]] = omp.map.bounds   lower_bound(%[[LOWER]] : i64) upper_bound(%[[UPPER]] : i64) extent(%[[EXTENT]] : i64) stride(%[[STRIDE]] : i64) start_idx(%[[STRIDE]] : i64)467// CHECK:           %[[MAP:.*]] = omp.map.info var_ptr(%[[VAL_1]] : !llvm.ptr, !llvm.array<512 x i32>)   map_clauses(tofrom) capture(ByRef) bounds(%[[BOUNDS]]) -> !llvm.ptr {name = "a"}468// CHECK:           omp.target thread_limit(%[[VAL_2]] : i32) map_entries(%[[MAP]] -> %[[ARG_0:.*]] : !llvm.ptr) {469// CHECK:             %[[VAL_3:.*]] = llvm.mlir.constant(10 : i32) : i32470// CHECK:             %[[VAL_4:.*]] = llvm.mlir.constant(1 : i64) : i64471// CHECK:             %[[VAL_5:.*]] = llvm.mlir.constant(1 : i64) : i64472// CHECK:             %[[VAL_6:.*]] = llvm.mlir.constant(0 : i64) : i64473// CHECK:             %[[VAL_7:.*]] = llvm.getelementptr %[[ARG_0]][0, %[[VAL_6]]] : (!llvm.ptr, i64) -> !llvm.ptr474// CHECK:             llvm.store %[[VAL_3]], %[[VAL_7]] : i32, !llvm.ptr475// CHECK:             omp.terminator476// CHECK:           }477// CHECK:           llvm.return478// CHECK:         }479 480// -----481 482func.func @_QPsimd_with_nested_loop() {483  %0 = fir.alloca i32 {adapt.valuebyref}484  %1 = fir.alloca !fir.array<10xi32> {bindc_name = "a", uniq_name = "_QFsimd_with_nested_loopEa"}485  %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsimd_with_nested_loopEi"}486  %3 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsimd_with_nested_loopEj"}487  %c1_i32 = arith.constant 1 : i32488  %c10_i32 = arith.constant 10 : i32489  %c1_i32_0 = arith.constant 1 : i32490  omp.simd {491    omp.loop_nest (%arg0) : i32 = (%c1_i32) to (%c10_i32) inclusive step (%c1_i32_0) {492      fir.store %arg0 to %0 : !fir.ref<i32>493      %c1_i32_1 = arith.constant 1 : i32494      %4 = fir.convert %c1_i32_1 : (i32) -> index495      %c10_i32_2 = arith.constant 10 : i32496      %5 = fir.convert %c10_i32_2 : (i32) -> index497      %c1 = arith.constant 1 : index498      %6 = fir.do_loop %arg1 = %4 to %5 step %c1 -> index {499        %8 = fir.convert %arg1 : (index) -> i32500        fir.store %8 to %3 : !fir.ref<i32>501        %9 = fir.load %0 : !fir.ref<i32>502        %10 = fir.load %0 : !fir.ref<i32>503        %11 = fir.convert %10 : (i32) -> i64504        %c1_i64 = arith.constant 1 : i64505        %12 = arith.subi %11, %c1_i64 : i64506        %13 = fir.coordinate_of %1, %12 : (!fir.ref<!fir.array<10xi32>>, i64) -> !fir.ref<i32>507        fir.store %9 to %13 : !fir.ref<i32>508        %14 = arith.addi %arg1, %c1 : index509        fir.result %14 : index510      }511      %7 = fir.convert %6 : (index) -> i32512      fir.store %7 to %3 : !fir.ref<i32>513      omp.yield514    }515  }516  return517}518 519// CHECK-LABEL:   llvm.func @_QPsimd_with_nested_loop() {520// CHECK:           %[[LOWER:.*]] = llvm.mlir.constant(1 : i32) : i32521// CHECK:           %[[UPPER:.*]] = llvm.mlir.constant(10 : i32) : i32522// CHECK:           %[[STEP:.*]] = llvm.mlir.constant(1 : i32) : i32523// CHECK:           omp.simd {524// CHECK-NEXT:        omp.loop_nest (%[[CNT:.*]]) : i32 = (%[[LOWER]]) to (%[[UPPER]]) inclusive step (%[[STEP]]) {525// CHECK:               llvm.br ^bb1(%[[VAL_1:.*]], %[[VAL_2:.*]] : i64, i64)526// CHECK:             ^bb1(%[[VAL_3:.*]]: i64, %[[VAL_4:.*]]: i64):527// CHECK:               %[[VAL_5:.*]] = llvm.mlir.constant(0 : index) : i64528// CHECK:               %[[VAL_6:.*]] = llvm.icmp "sgt" %[[VAL_4]], %[[VAL_5]] : i64529// CHECK:               llvm.cond_br %[[VAL_6]], ^bb2, ^bb3530// CHECK:             ^bb2:531// CHECK:               llvm.br ^bb1(%[[VAL_7:.*]], %[[VAL_8:.*]] : i64, i64)532// CHECK:             ^bb3:533// CHECK:               omp.yield534// CHECK:             }535// CHECK:           }536// CHECK:           llvm.return537// CHECK:         }538 539// -----540 541func.func @_QPomp_taskgroup() {542  omp.taskgroup {543    omp.task   {544      fir.call @_QPwork() : () -> ()545      omp.terminator546    }547    omp.terminator548  }549  return550}551func.func private @_QPwork()552 553// CHECK-LABEL: llvm.func @_QPomp_taskgroup() {554// CHECK:          omp.taskgroup   {555// CHECK:            omp.task   {556// CHECK:              llvm.call @_QPwork() : () -> ()557// CHECK:              omp.terminator558// CHECK:            }559// CHECK:            omp.terminator560// CHECK:          }561// CHECK:          llvm.return562// CHECK:        }563// CHECK:        llvm.func @_QPwork() attributes {sym_visibility = "private"}564// CHECK:      }565 566// -----567 568 569func.func @_QQmain() {570  %c0 = arith.constant 0 : index571  %c5 = arith.constant 5 : index572  %c1 = arith.constant 1 : index573  %0 = fir.alloca i32574  omp.taskgroup   {575    %1 = fir.convert %c1 : (index) -> i32576    cf.br ^bb1(%1, %c5 : i32, index)577  ^bb1(%2: i32, %3: index):  // 2 preds: ^bb0, ^bb2578    %4 = arith.cmpi sgt, %3, %c0 : index579    cf.cond_br %4, ^bb2, ^bb3580  ^bb2:  // pred: ^bb1581    fir.store %2 to %0 : !fir.ref<i32>582    omp.task   {583      fir.call @_QFPdo_work(%0) : (!fir.ref<i32>) -> ()584      omp.terminator585    }586    %5 = fir.load %0 : !fir.ref<i32>587    %6 = arith.addi %5, %1 : i32588    %7 = arith.subi %3, %c1 : index589    cf.br ^bb1(%6, %7 : i32, index)590  ^bb3:  // pred: ^bb1591    fir.store %2 to %0 : !fir.ref<i32>592    omp.terminator593  }594  return595}596func.func private @_QFPdo_work(!fir.ref<i32>)597 598// CHECK-LABEL: llvm.func @_QQmain599// CHECK:          omp.taskgroup   {600// CHECK:            omp.task   {601// CHECK:              llvm.call @_QFPdo_work({{.*}}) : (!llvm.ptr) -> ()602// CHECK:              omp.terminator603// CHECK:            }604// CHECK:            omp.terminator605// CHECK:          }606// CHECK:          llvm.return607// CHECK:        }608// CHECK:        llvm.func @_QFPdo_work(!llvm.ptr)609// CHECK:      }610 611// -----612 613func.func @_QPs() {614  %0 = fir.address_of(@_QFsEc) : !fir.ref<i32>615  omp.atomic.update   %0 : !fir.ref<i32> {616  ^bb0(%arg0: i32):617    %c1_i32 = arith.constant 1 : i32618    %1 = arith.addi %arg0, %c1_i32 : i32619    omp.yield(%1 : i32)620  }621  return622}623fir.global internal @_QFsEc : i32 {624  %c10_i32 = arith.constant 10 : i32625  fir.has_value %c10_i32 : i32626}627 628// CHECK-LABEL:  llvm.func @_QPs() {629// CHECK:    %[[GLOBAL_VAR:.*]] = llvm.mlir.addressof @[[GLOBAL:.*]] : !llvm.ptr630// CHECK:    omp.atomic.update   %[[GLOBAL_VAR]] : !llvm.ptr {631// CHECK:    ^bb0(%[[IN_VAL:.*]]: i32):632// CHECK:      %[[CONST_1:.*]] = llvm.mlir.constant(1 : i32) : i32633// CHECK:      %[[OUT_VAL:.*]] = llvm.add %[[IN_VAL]], %[[CONST_1]]  : i32634// CHECK:      omp.yield(%[[OUT_VAL]] : i32)635// CHECK:    }636// CHECK:    llvm.return637// CHECK:  }638// CHECK:  llvm.mlir.global internal @[[GLOBAL]]() {{.*}} : i32 {639// CHECK:    %[[INIT_10:.*]] = llvm.mlir.constant(10 : i32) : i32640// CHECK:    llvm.return %[[INIT_10]] : i32641// CHECK:  }642 643func.func @_QPsb() {644  %c10 = arith.constant 10 : index645  %c1 = arith.constant 1 : index646  %c1_i32 = arith.constant 1 : i32647  %c0_i32 = arith.constant 0 : i32648  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}649  %1 = fir.alloca i32 {bindc_name = "li", uniq_name = "_QFsbEli"}650  fir.store %c0_i32 to %1 : !fir.ref<i32>651  omp.sections   {652    omp.section {653      %2 = fir.convert %c1 : (index) -> i32654      %3 = fir.do_loop %arg0 = %c1 to %c10 step %c1 iter_args(%arg1 = %2) -> (i32) {655        fir.store %arg1 to %0 : !fir.ref<i32>656        %4 = fir.load %1 : !fir.ref<i32>657        %5 = arith.addi %4, %c1_i32 : i32658        fir.store %5 to %1 : !fir.ref<i32>659        %7 = fir.convert %c1 : (index) -> i32660        %8 = fir.load %0 : !fir.ref<i32>661        %9 = arith.addi %8, %7 : i32662        fir.result %9 : i32663      }664      fir.store %3 to %0 : !fir.ref<i32>665      omp.terminator666    }667    omp.terminator668  }669  return670}671 672// CHECK:  llvm.func @_QPsb() {673// CHECK:    %[[SIZE:.*]] = llvm.mlir.constant(1 : i64) : i64674// CHECK:    %[[LI_REF:.*]] = llvm.alloca %[[SIZE]] x i32 {bindc_name = "li"} : (i64) -> !llvm.ptr675// CHECK:    %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32676// CHECK:    omp.sections   {677// CHECK:      omp.section {678// CHECK:        llvm.br ^[[BB_ENTRY:.*]]({{.*}})679// CHECK:      ^[[BB_ENTRY]]({{.*}}):680// CHECK:        %[[EXIT_COND:.*]] = llvm.icmp "sgt"681// CHECK:        llvm.cond_br %[[EXIT_COND]], ^[[BB_LOOP_BODY:.*]], ^[[BB_EXIT:.*]]682// CHECK:      ^[[BB_LOOP_BODY]]:683// CHECK:        %[[LI_VAL:.*]] = llvm.load %[[LI_REF]] : !llvm.ptr -> i32684// CHECK:        %[[LI_INC:.*]] = llvm.add %[[LI_VAL]], %[[ONE]]  : i32685// CHECK:        llvm.store %[[LI_INC]], %[[LI_REF]] : i32, !llvm.ptr686// CHECK:        llvm.br ^[[BB_ENTRY]]({{.*}})687// CHECK:      ^[[BB_EXIT]]:688// CHECK:        omp.terminator689// CHECK:      }690// CHECK:      omp.terminator691// CHECK:    }692// CHECK:    llvm.return693// CHECK:  }694 695// -----696 697// CHECK:  omp.declare_reduction @[[EQV_REDUCTION:.*]] : i32 init {698// CHECK:  ^bb0(%{{.*}}: i32):699// CHECK:    %[[TRUE:.*]] = llvm.mlir.constant(1 : i64) : i32700// CHECK:    omp.yield(%[[TRUE]] : i32)701// CHECK:  } combiner {702// CHECK:  ^bb0(%[[ARG_1:.*]]: i32, %[[ARG_2:.*]]: i32):703// CHECK:    %[[ZERO_1:.*]] = llvm.mlir.constant(0 : i64) : i32704// CHECK:    %[[ARGVAL_1:.*]] = llvm.icmp "ne" %[[ARG_1]], %[[ZERO_1]] : i32705// CHECK:    %[[ZERO_2:.*]] = llvm.mlir.constant(0 : i64) : i32706// CHECK:    %[[ARGVAL_2:.*]] = llvm.icmp "ne" %[[ARG_2]], %[[ZERO_2]] : i32707// CHECK:    %[[RES:.*]] = llvm.icmp "eq" %[[ARGVAL_1]], %[[ARGVAL_2]] : i1708// CHECK:    %[[RES_EXT:.*]] = llvm.zext %[[RES]] : i1 to i32709// CHECK:    omp.yield(%[[RES_EXT]] : i32)710// CHECK:  }711// CHECK-LABEL:  @_QPsimple_reduction712// CHECK-SAME: %[[ARRAY_REF:.*]]: !llvm.ptr713// CHECK:    %[[VAL_1:.*]] = llvm.mlir.constant(1 : i64) : i64714// CHECK:    %[[RED_ACCUMULATOR:.*]] = llvm.alloca %[[VAL_1]] x i32 {bindc_name = "x"} : (i64) -> !llvm.ptr715// CHECK:    omp.parallel   {716// CHECK:      omp.wsloop reduction(@[[EQV_REDUCTION]] %[[RED_ACCUMULATOR]] -> %[[PRV:.+]] : !llvm.ptr) {717// CHECK-NEXT:   omp.loop_nest718// CHECK:          %[[ARRAY_ELEM_REF:.*]] = llvm.getelementptr %[[ARRAY_REF]][0, %{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr719// CHECK:          %[[ARRAY_ELEM:.*]] = llvm.load %[[ARRAY_ELEM_REF]] : !llvm.ptr -> i32720// CHECK:          %[[LPRV:.+]] = llvm.load %[[PRV]] : !llvm.ptr -> i32721// CHECK:          %[[ZERO_1:.*]] = llvm.mlir.constant(0 : i64) : i32722// CHECK:          %[[ARGVAL_1:.*]] = llvm.icmp "ne" %[[LPRV]], %[[ZERO_1]] : i32723// CHECK:          %[[ZERO_2:.*]] = llvm.mlir.constant(0 : i64) : i32724// CHECK:          %[[ARGVAL_2:.*]] = llvm.icmp "ne" %[[ARRAY_ELEM]], %[[ZERO_2]] : i32725// CHECK:          %[[RES:.*]] = llvm.icmp "eq" %[[ARGVAL_2]], %[[ARGVAL_1]] : i1726// CHECK:          %[[RES_EXT:.*]] = llvm.zext %[[RES]] : i1 to i32727// CHECK:          llvm.store %[[RES_EXT]], %[[PRV]] : i32, !llvm.ptr728// CHECK:          omp.yield729// CHECK:      omp.terminator730// CHECK:    llvm.return731 732omp.declare_reduction @eqv_reduction : !fir.logical<4> init {733^bb0(%arg0: !fir.logical<4>):734  %true = arith.constant true735  %0 = fir.convert %true : (i1) -> !fir.logical<4>736  omp.yield(%0 : !fir.logical<4>)737} combiner {738^bb0(%arg0: !fir.logical<4>, %arg1: !fir.logical<4>):739  %0 = fir.convert %arg0 : (!fir.logical<4>) -> i1740  %1 = fir.convert %arg1 : (!fir.logical<4>) -> i1741  %2 = arith.cmpi eq, %0, %1 : i1742  %3 = fir.convert %2 : (i1) -> !fir.logical<4>743  omp.yield(%3 : !fir.logical<4>)744}745func.func @_QPsimple_reduction(%arg0: !fir.ref<!fir.array<100x!fir.logical<4>>> {fir.bindc_name = "y"}) {746  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsimple_reductionEi"}747  %1 = fir.alloca !fir.logical<4> {bindc_name = "x", uniq_name = "_QFsimple_reductionEx"}748  %true = arith.constant true749  %2 = fir.convert %true : (i1) -> !fir.logical<4>750  fir.store %2 to %1 : !fir.ref<!fir.logical<4>>751  omp.parallel   {752    %3 = fir.alloca i32 {adapt.valuebyref, pinned}753    %c1_i32 = arith.constant 1 : i32754    %c100_i32 = arith.constant 100 : i32755    %c1_i32_0 = arith.constant 1 : i32756    omp.wsloop reduction(@eqv_reduction %1 -> %prv : !fir.ref<!fir.logical<4>>) {757      omp.loop_nest (%arg1) : i32 = (%c1_i32) to (%c100_i32) inclusive step (%c1_i32_0) {758        fir.store %arg1 to %3 : !fir.ref<i32>759        %4 = fir.load %3 : !fir.ref<i32>760        %5 = fir.convert %4 : (i32) -> i64761        %c1_i64 = arith.constant 1 : i64762        %6 = arith.subi %5, %c1_i64 : i64763        %7 = fir.coordinate_of %arg0, %6 : (!fir.ref<!fir.array<100x!fir.logical<4>>>, i64) -> !fir.ref<!fir.logical<4>>764        %8 = fir.load %7 : !fir.ref<!fir.logical<4>>765        %lprv = fir.load %prv : !fir.ref<!fir.logical<4>>766        %lprv1 = fir.convert %lprv : (!fir.logical<4>) -> i1767        %9 = fir.convert %8 : (!fir.logical<4>) -> i1768        %10 = arith.cmpi eq, %9, %lprv1 : i1769        %11 = fir.convert %10 : (i1) -> !fir.logical<4>770        fir.store %11 to %prv : !fir.ref<!fir.logical<4>>771        omp.yield772      }773    }774    omp.terminator775  }776  return777}778 779// -----780 781// CHECK: llvm.func @_QPs782// CHECK: omp.atomic.read %{{.*}} = %{{.*}}   : !llvm.ptr, !llvm.ptr, !llvm.struct<(f32, f32)>783 784func.func @_QPs(%arg0: !fir.ref<complex<f32>> {fir.bindc_name = "x"}) {785  %0 = fir.alloca complex<f32> {bindc_name = "v", uniq_name = "_QFsEv"}786  omp.atomic.read %0 = %arg0   : !fir.ref<complex<f32>>, !fir.ref<complex<f32>>, complex<f32>787  return788}789 790// -----791 792// Test if llvm.alloca is properly inserted in the omp section793 794//CHECK:  %[[CONST0:.*]] = llvm.mlir.constant(1 : i64) : i64795//CHECK:  %[[CONST:.*]] = llvm.mlir.constant(1 : i64) : i64796//CHECK:  %[[ALLOCA:.*]] = llvm.alloca %[[CONST]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8)> {bindc_name = "iattr"} : (i64) -> !llvm.ptr797//CHECK:  omp.parallel   {798//CHECK:    %[[CONST_1:.*]] = llvm.mlir.constant(1 : i32) : i32799//CHECK:    %[[ALLOCA_1:.*]] = llvm.alloca %[[CONST_1:.*]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8)> {alignment = 8 : i64} : (i32) -> !llvm.ptr800//CHECK:    %[[SIZE:.*]] = llvm.mlir.constant(24 : i32) : i32801//CHECK:    "llvm.intr.memcpy"(%[[ALLOCA_1]], %[[ALLOCA]], %[[SIZE]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()802//CHECK:    %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA_1]][0, 0] : (!llvm.ptr) -> !llvm.ptr803//CHECK:    %[[LOAD_2:.*]] = llvm.load %[[GEP]] : !llvm.ptr -> !llvm.ptr804//CHECK:    omp.terminator805//CHECK:  }806 807func.func @_QQmain() attributes {fir.bindc_name = "mn"} {808  %0 = fir.alloca !fir.box<!fir.ptr<i32>> {bindc_name = "iattr", uniq_name = "_QFEiattr"}809  %1 = fir.zero_bits !fir.ptr<i32>810  %2 = fir.embox %1 : (!fir.ptr<i32>) -> !fir.box<!fir.ptr<i32>>811  fir.store %2 to %0 : !fir.ref<!fir.box<!fir.ptr<i32>>>812  %3 = fir.address_of(@_QFEx) : !fir.ref<i32>813  %4 = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFEy"}814  %5 = fir.embox %3 : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>>815  fir.store %5 to %0 : !fir.ref<!fir.box<!fir.ptr<i32>>>816  omp.parallel   {817    %6 = fir.load %4 : !fir.ref<i32>818    %7 = fir.load %0 : !fir.ref<!fir.box<!fir.ptr<i32>>>819    %8 = fir.box_addr %7 : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>820    fir.store %6 to %8 : !fir.ptr<i32>821    omp.terminator822  }823  return824}825fir.global internal @_QFEx target : i32 {826  %0 = fir.zero_bits i32827  fir.has_value %0 : i32828}829 830// -----831 832// Test if llvm.alloca is properly inserted in the omp ordered region833 834// CHECK: llvm.func @sub_835func.func @sub_() {836  %c0 = arith.constant 0 : index837  %c1 = arith.constant 1 : index838  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsubEi"}839// CHECK: omp.ordered.region840  omp.ordered.region {841    %1 = fir.convert %c1 : (index) -> i32842    cf.br ^bb1(%1, %c1 : i32, index)843  ^bb1(%2: i32, %3: index):  // 2 preds: ^bb0, ^bb2844    %4 = arith.cmpi sgt, %3, %c0 : index845    cf.cond_br %4, ^bb2, ^bb3846  ^bb2:  // pred: ^bb1847    fir.store %2 to %0 : !fir.ref<i32>848    %5 = fir.load %0 : !fir.ref<i32>849// CHECK: llvm.add850    %6 = arith.addi %5, %1 : i32851// CHECK: llvm.sub852    %7 = arith.subi %3, %c1 : index853    cf.br ^bb1(%6, %7 : i32, index)854  ^bb3:  // pred: ^bb1855    fir.store %2 to %0 : !fir.ref<i32>856// CHECK: omp.terminator857    omp.terminator858  }859  return860}861 862// -----863 864// CHECK-LABEL:  llvm.func @flush_standalone_865// CHECK-SAME:   %[[ARG_A:.*]]: !llvm.ptr {fir.bindc_name = "a"}, %[[ARG_B:.*]]: !llvm.ptr {fir.bindc_name = "b"}, %[[ARG_C:.*]]: !llvm.ptr {fir.bindc_name = "c"})866  func.func @flush_standalone_(%arg0: !fir.ref<i32> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "b"}, %arg2: !fir.ref<i32> {fir.bindc_name = "c"}) {867// CHECK:   omp.flush(%[[ARG_A]], %[[ARG_B]], %[[ARG_C]] : !llvm.ptr, !llvm.ptr, !llvm.ptr)868    omp.flush(%arg0, %arg1, %arg2 : !fir.ref<i32>, !fir.ref<i32>, !fir.ref<i32>)869// CHECK:   omp.flush870    omp.flush871    return872  }873 874// CHECK-LABEL:  llvm.func @flush_parallel_875// CHECK-SAME:   %[[ARG_A:.*]]: !llvm.ptr {fir.bindc_name = "a"}, %[[ARG_B:.*]]: !llvm.ptr {fir.bindc_name = "b"}, %[[ARG_C:.*]]: !llvm.ptr {fir.bindc_name = "c"})876  func.func @flush_parallel_(%arg0: !fir.ref<i32> {fir.bindc_name = "a"}, %arg1: !fir.ref<i32> {fir.bindc_name = "b"}, %arg2: !fir.ref<i32> {fir.bindc_name = "c"}) {877// CHECK:    omp.parallel   {878    omp.parallel   {879// CHECK:      omp.flush(%[[ARG_A]], %[[ARG_B]], %[[ARG_C]] : !llvm.ptr, !llvm.ptr, !llvm.ptr)880      omp.flush(%arg0, %arg1, %arg2 : !fir.ref<i32>, !fir.ref<i32>, !fir.ref<i32>)881// CHECK:      omp.flush882      omp.flush883// CHECK:      %[[A_VAL:.*]] = llvm.load %[[ARG_A]] : !llvm.ptr -> i32884      %0 = fir.load %arg0 : !fir.ref<i32>885// CHECK:      %[[B_VAL:.*]] = llvm.load %[[ARG_B]] : !llvm.ptr -> i32886      %1 = fir.load %arg1 : !fir.ref<i32>887// CHECK:      %[[C_VAL:.*]] = llvm.add %[[A_VAL]], %[[B_VAL]]  : i32888      %2 = arith.addi %0, %1 : i32889// CHECK:      llvm.store %[[C_VAL]], %[[ARG_C]] : i32, !llvm.ptr890      fir.store %2 to %arg2 : !fir.ref<i32>891// CHECK:      omp.terminator892      omp.terminator893// CHECK:    }894    }895    return896  }897 898// -----899 900// CHECK:  omp.critical.declare @help   hint(contended)901omp.critical.declare @help hint(contended)902 903// CHECK: llvm.func @omp_critical_() {904func.func @omp_critical_() {905// CHECK: %[[Y_REF:.*]] = llvm.alloca %{{.*}} x i32 {bindc_name = "y"} : (i64) -> !llvm.ptr906  %0 = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFomp_criticalEx"}907// CHECK: %[[X_REF:.*]] = llvm.alloca %{{.*}} x i32 {bindc_name = "x"} : (i64) -> !llvm.ptr908  %1 = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFomp_criticalEy"}909// CHECK: omp.critical(@help)910  omp.critical(@help) {911// CHECK: %[[X_VAL:.*]] = llvm.load %[[X_REF]] : !llvm.ptr -> i32912    %2 = fir.load %0 : !fir.ref<i32>913// CHECK: %[[Y_VAL:.*]] = llvm.load %[[Y_REF]] : !llvm.ptr -> i32914    %3 = fir.load %1 : !fir.ref<i32>915// CHECK: %[[RESULT:.*]] = llvm.add %[[X_VAL]], %[[Y_VAL]]  : i32916    %4 = arith.addi %2, %3 : i32917// CHECK: llvm.store %[[RESULT]], %[[X_REF]] : i32, !llvm.ptr918    fir.store %4 to %0 : !fir.ref<i32>919// CHECK: omp.terminator920    omp.terminator921  }922  return923}924 925// -----926 927// CHECK-LABEL:  llvm.func @omp_map_info_descriptor_type_conversion928// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)929 930func.func @omp_map_info_descriptor_type_conversion(%arg0 : !fir.ref<!fir.box<!fir.heap<i32>>>) {931  // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8)>932  %0 = fir.box_offset %arg0 base_addr : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> !fir.llvm_ptr<!fir.ref<i32>>933  // CHECK: %[[MEMBER_MAP:.*]] = omp.map.info var_ptr(%[[GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = ""}934  %1 = omp.map.info var_ptr(%0 : !fir.llvm_ptr<!fir.ref<i32>>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.llvm_ptr<!fir.ref<i32>> {name = ""}935  // CHECK: %[[DESC_MAP:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8)>) map_clauses(always, delete) capture(ByRef) members(%[[MEMBER_MAP]] : [0] : !llvm.ptr) -> !llvm.ptr {name = ""}936  %2 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.heap<i32>>) map_clauses(always, delete) capture(ByRef) members(%1 : [0] : !fir.llvm_ptr<!fir.ref<i32>>) -> !fir.ref<!fir.box<!fir.heap<i32>>> {name = ""}937  // CHECK: omp.target_exit_data map_entries(%[[DESC_MAP]] : !llvm.ptr)938  omp.target_exit_data   map_entries(%2 : !fir.ref<!fir.box<!fir.heap<i32>>>)939  return940}941 942// -----943 944// CHECK-LABEL:  llvm.func @omp_map_info_derived_type_explicit_member_conversion945// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)946 947func.func @omp_map_info_derived_type_explicit_member_conversion(%arg0 : !fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>>) {948  // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFderived_type", (f32, array<10 x i32>, i32)>949  %1 = fir.coordinate_of %arg0, int : (!fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>>) -> !fir.ref<i32>950  // CHECK: %[[MAP_MEMBER_1:.*]] = omp.map.info var_ptr(%[[GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "dtype%int"}951  %2 = omp.map.info var_ptr(%1 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {name = "dtype%int"}952  // CHECK: %[[GEP_2:.*]] = llvm.getelementptr %[[ARG_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFderived_type", (f32, array<10 x i32>, i32)>953  %4 = fir.coordinate_of %arg0, real : (!fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>>) -> !fir.ref<f32>954  // CHECK: %[[MAP_MEMBER_2:.*]] = omp.map.info var_ptr(%[[GEP_2]] : !llvm.ptr, f32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "dtype%real"}955  %5 = omp.map.info var_ptr(%4 : !fir.ref<f32>, f32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<f32> {name = "dtype%real"}956  // CHECK: %[[MAP_PARENT:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, !llvm.struct<"_QFderived_type", (f32, array<10 x i32>, i32)>) map_clauses(tofrom) capture(ByRef) members(%[[MAP_MEMBER_1]], %[[MAP_MEMBER_2]] : [2], [0] : !llvm.ptr, !llvm.ptr) -> !llvm.ptr {name = "dtype", partial_map = true}957  %6 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>>, !fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>) map_clauses(tofrom) capture(ByRef) members(%2, %5 : [2], [0] : !fir.ref<i32>, !fir.ref<f32>) -> !fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>> {name = "dtype", partial_map = true}958  // CHECK: omp.target map_entries(%[[MAP_MEMBER_1]] -> %[[ARG_1:.*]], %[[MAP_MEMBER_2]] -> %[[ARG_2:.*]], %[[MAP_PARENT]] -> %[[ARG_3:.*]] : !llvm.ptr, !llvm.ptr, !llvm.ptr) {959  omp.target map_entries(%2 -> %arg1, %5 -> %arg2, %6 -> %arg3 : !fir.ref<i32>, !fir.ref<f32>, !fir.ref<!fir.type<_QFderived_type{real:f32,array:!fir.array<10xi32>,int:i32}>>) {960    omp.terminator961  }962  return963}964 965// -----966 967// CHECK-LABEL:  llvm.func @omp_map_info_nested_derived_type_explicit_member_conversion968// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)969 970func.func @omp_map_info_nested_derived_type_explicit_member_conversion(%arg0 : !fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>>) {971    // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFTtop_layer", (array<10 x i32>, struct<"_QFTbottom_layer", (array<10 x f32>, f64)>, i32)>972    %1 = fir.coordinate_of %arg0, nested : (!fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>>) -> !fir.ref<!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>>973    // CHECK: %[[GEP_2:.*]] = llvm.getelementptr %[[GEP]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFTbottom_layer", (array<10 x f32>, f64)>974    %3 = fir.coordinate_of %1, i2 : (!fir.ref<!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>>) -> !fir.ref<f64>975    // CHECK: %[[MAP_MEMBER_1:.*]] = omp.map.info var_ptr(%[[GEP_2]] : !llvm.ptr, f64) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr976    %4 = omp.map.info var_ptr(%3 : !fir.ref<f64>, f64) map_clauses(tofrom) capture(ByRef) -> !fir.ref<f64>977    // CHECK: %[[GEP_3:.*]] = llvm.getelementptr %[[ARG_0]][0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFTtop_layer", (array<10 x i32>, struct<"_QFTbottom_layer", (array<10 x f32>, f64)>, i32)>978    %6 = fir.coordinate_of %arg0, k : (!fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>>) -> !fir.ref<i32>979    // CHECK: %[[MAP_MEMBER_2:.*]] = omp.map.info var_ptr(%[[GEP_3]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr980    %7 = omp.map.info var_ptr(%6 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32>981    // CHECK: %[[PARENT_MAP:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, !llvm.struct<"_QFTtop_layer", (array<10 x i32>, struct<"_QFTbottom_layer", (array<10 x f32>, f64)>, i32)>) map_clauses(tofrom) capture(ByRef) members(%[[MAP_MEMBER_1]], %[[MAP_MEMBER_2]] : [1, 1], [2] : !llvm.ptr, !llvm.ptr) -> !llvm.ptr {partial_map = true}982    %9 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>>, !fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>) map_clauses(tofrom) capture(ByRef) members(%4, %7 : [1,1], [2] : !fir.ref<f64>, !fir.ref<i32>) -> !fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>> {partial_map = true}983    // CHECK: omp.target map_entries(%[[MAP_MEMBER_1]] -> %{{.*}}, %[[MAP_MEMBER_2]] -> %{{.*}}, %[[PARENT_MAP]] -> %{{.*}} : !llvm.ptr, !llvm.ptr, !llvm.ptr) {984    omp.target map_entries(%4 -> %arg1, %7 -> %arg2, %9 -> %arg3 : !fir.ref<f64>, !fir.ref<i32>, !fir.ref<!fir.type<_QFTtop_layer{array_i:!fir.array<10xi32>,nested:!fir.type<_QFTbottom_layer{array_i2:!fir.array<10xf32>,i2:f64}>,k:i32}>>) {985      omp.terminator986    }987  return988}989 990// -----991 992// CHECK-LABEL:  llvm.func @omp_map_common_block_using_common_block_symbol993 994// CHECK: %[[ADDR_OF:.*]] = llvm.mlir.addressof @var_common_ : !llvm.ptr995// CHECK: %[[CB_MAP:.*]] = omp.map.info var_ptr(%[[ADDR_OF]] : !llvm.ptr, !llvm.array<8 x i8>) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "var_common"}996// CHECK:    omp.target map_entries(%[[CB_MAP]] -> %[[ARG0:.*]] : !llvm.ptr) {997// CHECK:      %[[VAR_2_OFFSET:.*]] = llvm.mlir.constant(4 : index) : i64998// CHECK:      %[[VAR_1_OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64999// CHECK:      %{{.*}} = llvm.getelementptr %[[ARG0]][%[[VAR_1_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i81000// CHECK:      %{{.*}} = llvm.getelementptr %[[ARG0]][%[[VAR_2_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i81001 1002func.func @omp_map_common_block_using_common_block_symbol() {1003  %0 = fir.address_of(@var_common_) : !fir.ref<!fir.array<8xi8>>1004  %1 = omp.map.info var_ptr(%0 : !fir.ref<!fir.array<8xi8>>, !fir.array<8xi8>) map_clauses(tofrom) capture(ByRef) -> !fir.ref<!fir.array<8xi8>> {name = "var_common"}1005  omp.target map_entries(%1 -> %arg0 : !fir.ref<!fir.array<8xi8>>) {1006    %c4 = arith.constant 4 : index1007    %c0 = arith.constant 0 : index1008    %c20_i32 = arith.constant 20 : i321009    %2 = fir.convert %arg0 : (!fir.ref<!fir.array<8xi8>>) -> !fir.ref<!fir.array<?xi8>>1010    %3 = fir.coordinate_of %2, %c0 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>1011    %4 = fir.convert %3 : (!fir.ref<i8>) -> !fir.ref<i32>1012    %5 = fir.convert %arg0 : (!fir.ref<!fir.array<8xi8>>) -> !fir.ref<!fir.array<?xi8>>1013    %6 = fir.coordinate_of %5, %c4 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>1014    %7 = fir.convert %6 : (!fir.ref<i8>) -> !fir.ref<i32>1015    %8 = fir.load %4 : !fir.ref<i32>1016    %9 = arith.addi %8, %c20_i32 : i321017    fir.store %9 to %7 : !fir.ref<i32>1018    omp.terminator1019  }1020  return1021}1022 1023fir.global common @var_common_(dense<0> : vector<8xi8>) {alignment = 4 : i64} : !fir.array<8xi8>1024 1025// -----1026 1027// CHECK-LABEL:  llvm.func @omp_map_common_block_using_common_block_members1028 1029// CHECK:    %[[VAR_2_OFFSET:.*]] = llvm.mlir.constant(4 : index) : i641030// CHECK:    %[[VAR_1_OFFSET:.*]] = llvm.mlir.constant(0 : index) : i641031// CHECK:    %[[ADDR_OF:.*]] = llvm.mlir.addressof @var_common_ : !llvm.ptr1032// CHECK:    %[[VAR_1_CB_GEP:.*]] = llvm.getelementptr %[[ADDR_OF]][%[[VAR_1_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i81033// CHECK:    %[[VAR_2_CB_GEP:.*]] = llvm.getelementptr %[[ADDR_OF]][%[[VAR_2_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i81034// CHECK:    %[[MAP_CB_VAR_1:.*]] = omp.map.info var_ptr(%[[VAR_1_CB_GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "var1"}1035// CHECK:    %[[MAP_CB_VAR_2:.*]] = omp.map.info var_ptr(%[[VAR_2_CB_GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "var2"}1036// CHECK:    omp.target map_entries(%[[MAP_CB_VAR_1]] -> %[[ARG0:.*]], %[[MAP_CB_VAR_2]] -> %[[ARG1:.*]] : !llvm.ptr, !llvm.ptr) {1037 1038func.func @omp_map_common_block_using_common_block_members() {1039  %c4 = arith.constant 4 : index1040  %c0 = arith.constant 0 : index1041  %0 = fir.address_of(@var_common_) : !fir.ref<!fir.array<8xi8>>1042  %1 = fir.convert %0 : (!fir.ref<!fir.array<8xi8>>) -> !fir.ref<!fir.array<?xi8>>1043  %2 = fir.coordinate_of %1, %c0 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>1044  %3 = fir.convert %2 : (!fir.ref<i8>) -> !fir.ref<i32>1045  %4 = fir.convert %0 : (!fir.ref<!fir.array<8xi8>>) -> !fir.ref<!fir.array<?xi8>>1046  %5 = fir.coordinate_of %4, %c4 : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>1047  %6 = fir.convert %5 : (!fir.ref<i8>) -> !fir.ref<i32>1048  %7 = omp.map.info var_ptr(%3 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {name = "var1"}1049  %8 = omp.map.info var_ptr(%6 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {name = "var2"}1050  omp.target map_entries(%7 -> %arg0, %8 -> %arg1 : !fir.ref<i32>, !fir.ref<i32>) {1051    %c10_i32 = arith.constant 10 : i321052    %9 = fir.load %arg0 : !fir.ref<i32>1053    %10 = arith.muli %9, %c10_i32 : i321054    fir.store %10 to %arg1 : !fir.ref<i32>1055    omp.terminator1056  }1057  return1058}1059 1060fir.global common @var_common_(dense<0> : vector<8xi8>) {alignment = 4 : i64} : !fir.array<8xi8>1061 1062// -----1063 1064 1065func.func @use_string(%arg0 : !fir.ref<!fir.char<1,?>>) {1066  return1067}1068 1069func.func @use_index(%arg0 : index) {1070  return1071}1072 1073// CHECK-LABEL:   llvm.func @alloca_hoisting_openmp() {1074// CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(6 : index) : i641075// CHECK:           %[[VAL_1:.*]] = llvm.mlir.constant(1 : i32) : i321076// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(42 : i32) : i321077// CHECK:           omp.parallel {1078// CHECK:             %[[VAL_3:.*]] = llvm.mlir.constant(6 : index) : i641079// CHECK:             %[[VAL_4:.*]] = llvm.alloca %[[VAL_3]] x i8 : (i64) -> !llvm.ptr1080// CHECK:             omp.wsloop {1081// CHECK:               omp.loop_nest (%[[VAL_5:.*]]) : i32 = (%[[VAL_1]]) to (%[[VAL_2]]) inclusive step (%[[VAL_1]]) {1082// CHECK:                 %[[VAL_6:.*]] = llvm.mlir.constant(1 : i64) : i641083// CHECK:                 llvm.call @use_string(%[[VAL_4]]) : (!llvm.ptr) -> ()1084// CHECK:                 omp.yield1085// CHECK:               }1086// CHECK:             }1087// CHECK:             omp.terminator1088// CHECK:           }1089// CHECK:           llvm.call @use_index(%[[VAL_0]]) : (i64) -> ()1090// CHECK:           llvm.return1091// CHECK:         }1092func.func @alloca_hoisting_openmp() {1093  %c6 = arith.constant 6 : index1094  %c1_i32 = arith.constant 1 : i321095  %c42_i32 = arith.constant 42 : i321096  omp.parallel {1097    omp.wsloop {1098      omp.loop_nest (%arg0) : i32 = (%c1_i32) to (%c42_i32) inclusive step (%c1_i32) {1099        %0 = fir.alloca !fir.char<1,?>(%c6 : index)1100        fir.call @use_string(%0) : (!fir.ref<!fir.char<1,?>>) -> ()1101        omp.yield1102      }1103    }1104    omp.terminator1105  }1106  fir.call @use_index(%c6) : (index) -> ()1107  return1108}1109 1110// -----1111 1112// NOTE: This test (and the other allocatable member map tests below) uses mock1113// bounds to simplify the example, the real bounds generation is more complex1114// as it has to access the box information. However, it's not what the test1115// aims to check. The test aims to check the parent member bindings and1116// acceses are appropriately maintained when lowering to the LLVM dialect.1117 1118// CHECK-LABEL:  llvm.func @map_dtype_alloca_mem1119// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)1120func.func @map_dtype_alloca_mem(%arg0 : !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) {1121  %c4 = arith.constant 4 : index1122  %c1 = arith.constant 1 : index1123  %c0 = arith.constant 0 : index1124  // CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound({{.*}}) upper_bound({{.*}}) extent({{.*}}) stride({{.*}}) start_idx({{.*}}) {stride_in_bytes = true}1125  %0 = omp.map.bounds lower_bound(%c0 : index) upper_bound(%c4 : index) extent(%c4 : index) stride(%c1 : index) start_idx(%c0 : index) {stride_in_bytes = true}1126  // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 4] : (!llvm.ptr) -> !llvm.ptr, [[STRUCT_TY:!llvm.struct<"_QFRecTy", \(f32, struct<\(ptr, i64, i32, i8, i8, i8, i8\)>, array<10 x i32>, f32, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32\)>]]1127  %1 = fir.coordinate_of %arg0, array_j : (!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1128  // CHECK: %[[BADDR_GEP:.*]] = llvm.getelementptr %[[GEP]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[STRUCT_TY2:!llvm.struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>]]1129  %2 = fir.box_offset %1 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1130  // CHECK: %[[MAP_MEMBER_BADDR:.*]] = omp.map.info var_ptr(%[[GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[BADDR_GEP]] : !llvm.ptr) bounds(%[[BOUNDS]]) -> !llvm.ptr1131  %3 = omp.map.info var_ptr(%1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.array<?xi32>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%2 : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%0) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1132  // CHECK: %[[MAP_MEMBER_DESCRIPTOR:.*]] = omp.map.info var_ptr(%[[GEP]] : !llvm.ptr, [[STRUCT_TY2]]) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1133  %4 = omp.map.info var_ptr(%1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1134  // CHECK: %[[MAP_PARENT_DTYPE:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[STRUCT_TY]]) map_clauses(tofrom) capture(ByRef) members(%[[MAP_MEMBER_DESCRIPTOR]], %[[MAP_MEMBER_BADDR]] : [4], [4, 0] : !llvm.ptr, !llvm.ptr) -> !llvm.ptr {partial_map = true}1135  %5 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>, !fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>) map_clauses(tofrom) capture(ByRef) members(%4, %3 : [4], [4,0] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>> {partial_map = true}1136  // CHECK: omp.target map_entries(%[[MAP_MEMBER_DESCRIPTOR]] -> %[[ARG_1:.*]], %[[MAP_MEMBER_BADDR]] -> %[[ARG_2:.*]], %[[MAP_PARENT_DTYPE]] -> %[[ARG_3:.*]] : !llvm.ptr, !llvm.ptr, !llvm.ptr) {1137  omp.target map_entries(%4 -> %arg1, %3 -> %arg2, %5 -> %arg3 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) {1138    omp.terminator1139  }1140  return1141}1142 1143// -----1144 1145// CHECK-LABEL:  llvm.func @map_dtype_alloca_mem21146// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)1147func.func @map_dtype_alloca_mem2(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>) {1148  // CHECK: %[[DTYPE_ALLOCATABLE_ALOCA_2:.*]] = llvm.alloca {{.*}} x [[DESC_TY:!llvm.struct<\(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>\)>]] {alignment = 8 : i64} : (i32) -> !llvm.ptr1149  // CHECK: %[[DTYPE_ALLOCATABLE_ALOCA:.*]] = llvm.alloca {{.*}} x [[DESC_TY]] {alignment = 8 : i64} : (i32) -> !llvm.ptr1150  %c5 = arith.constant 5 : index1151  %c4 = arith.constant 4 : index1152  %c1 = arith.constant 1 : index1153  %c0 = arith.constant 0 : index1154  // CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound({{.*}}) upper_bound({{.*}}) extent({{.*}}) stride({{.*}}) start_idx({{.*}}) {stride_in_bytes = true}1155  %0 = omp.map.bounds lower_bound(%c0 : index) upper_bound(%c4 : index) extent(%c4 : index) stride(%c1 : index) start_idx(%c0 : index) {stride_in_bytes = true}1156  // CHECK: "llvm.intr.memcpy"(%[[DTYPE_ALLOCATABLE_ALOCA]], %[[ARG_0]], {{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()1157  %1 = fir.load %arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>1158  // CHECK: %[[GEP_DTYPE_BADDR:.*]] = llvm.getelementptr %[[DTYPE_ALLOCATABLE_ALOCA]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1159  // CHECK: %[[LOAD_DTYPE_BADDR:.*]] = llvm.load %[[GEP_DTYPE_BADDR]] : !llvm.ptr -> !llvm.ptr1160  // CHECK: %[[GEP_DTYPE_MEMBER:.*]] = llvm.getelementptr %[[LOAD_DTYPE_BADDR]][0, 4] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY:!llvm.struct<"_QFRecTy", \(f32, struct<\(ptr, i64, i32, i8, i8, i8, i8\)>, array<10 x i32>, f32, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32\)>]]1161  %2 = fir.coordinate_of %1, array_j : (!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1162  // CHECK: %[[DTYPE_MEMBER_BADDR:.*]] = llvm.getelementptr %[[GEP_DTYPE_MEMBER]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY2:!llvm.struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>]]1163  %3 = fir.box_offset %2 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1164  // CHECK: %[[MAP_MEMBER_BADDR:.*]] = omp.map.info var_ptr(%[[GEP_DTYPE_MEMBER]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[DTYPE_MEMBER_BADDR]] : !llvm.ptr) bounds(%[[BOUNDS]]) -> !llvm.ptr1165  %4 = omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.array<?xi32>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%3 : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%0) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1166  // CHECK: %[[MAP_MEMBER_DESC:.*]] = omp.map.info var_ptr(%[[GEP_DTYPE_MEMBER]] : !llvm.ptr, [[DESC_TY2]]) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1167  %5 = omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1168  // CHECK: "llvm.intr.memcpy"(%[[DTYPE_ALLOCATABLE_ALOCA_2]], %[[ARG_0]], {{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()1169  %6 = fir.load %arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>1170  // CHECK: %[[GEP_DTYPE_BADDR:.*]] = llvm.getelementptr %[[DTYPE_ALLOCATABLE_ALOCA_2]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1171  // CHECK: %[[LOAD_DTYPE_BADDR:.*]] = llvm.load %[[GEP_DTYPE_BADDR]] : !llvm.ptr -> !llvm.ptr1172  // CHECK: %[[GEP_DTYPE_REGULAR_MEMBER:.*]] = llvm.getelementptr %[[LOAD_DTYPE_BADDR]][0, 5] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY]]1173  %7 = fir.coordinate_of %6, k : (!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>) -> !fir.ref<i32>1174  // CHECK: %[[MAP_REGULAR_MEMBER:.*]] = omp.map.info var_ptr(%[[GEP_DTYPE_REGULAR_MEMBER]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1175  %8 = omp.map.info var_ptr(%7 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32>1176  // CHECK: %[[GEP_DTYPE_BADDR:.*]] = llvm.getelementptr %[[ARG_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1177  %9 = fir.box_offset %arg0 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>1178  // CHECK: %[[MAP_DTYPE_PARENT_BADDR:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[REC_TY]]) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[GEP_DTYPE_BADDR]] : !llvm.ptr) -> !llvm.ptr1179  %10 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>, !fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%9 : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>) -> !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>1180  // CHECK: %[[MAP_DTYPE_PARENT_DESC:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[DESC_TY]]) map_clauses(tofrom) capture(ByRef) members(%[[MAP_DTYPE_PARENT_BADDR]], %[[MAP_MEMBER_DESC]], %[[MAP_MEMBER_BADDR]], %[[MAP_REGULAR_MEMBER]] : [0], [0, 4], [0, 4, 0], [0, 5] : !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.ptr1181  %11 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>, !fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>) map_clauses(tofrom) capture(ByRef) members(%10, %5, %4, %8 : [0], [0,4], [0,4,0], [0,5] : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) -> !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>1182  // CHECK: omp.target map_entries(%[[MAP_DTYPE_PARENT_BADDR]] -> %[[ARG_1:.*]], %[[MAP_MEMBER_DESC]] -> %[[ARG_2:.*]], %[[MAP_MEMBER_BADDR]] -> %[[ARG_3:.*]], %[[MAP_REGULAR_MEMBER]] -> %[[ARG_4:.*]], %[[MAP_DTYPE_PARENT_DESC]] -> %[[ARG_5:.*]] : !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) {1183  omp.target map_entries(%10 -> %arg1, %5 -> %arg2, %4 -> %arg3, %8 -> %arg4, %11 -> %arg5 : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>, !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>>>) {1184   omp.terminator1185  }1186  return1187}1188 1189// -----1190 1191// CHECK-LABEL:  llvm.func @map_nested_dtype_alloca_mem1192// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)1193func.func @map_nested_dtype_alloca_mem(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>) {1194  // CHECK: %[[DTYPE_ALLOCATABLE_ALOCA_2:.*]] = llvm.alloca {{.*}} x [[DESC_TY:!llvm.struct<\(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>\)>]] {alignment = 8 : i64} : (i32) -> !llvm.ptr1195  // CHECK: %[[DTYPE_ALLOCATABLE_ALOCA:.*]] = llvm.alloca {{.*}} x [[DESC_TY]] {alignment = 8 : i64} : (i32) -> !llvm.ptr1196  %c3 = arith.constant 3 : index1197  %c4 = arith.constant 4 : index1198  %c6 = arith.constant 6 : index1199  %c1 = arith.constant 1 : index1200  %c2 = arith.constant 2 : index1201  %c0 = arith.constant 0 : index1202  // CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound({{.*}}) upper_bound({{.*}}) extent({{.*}}) stride({{.*}}) start_idx({{.*}}) {stride_in_bytes = true}1203  %0 = omp.map.bounds lower_bound(%c0 : index) upper_bound(%c4 : index) extent(%c4 : index) stride(%c1 : index) start_idx(%c0 : index) {stride_in_bytes = true}1204  // CHECK: "llvm.intr.memcpy"(%[[DTYPE_ALLOCATABLE_ALOCA]], %[[ARG_0]], {{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()1205  %1 = fir.load %arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>1206  // CHECK: %[[GEP_DTYPE_BADDR:.*]] = llvm.getelementptr %[[DTYPE_ALLOCATABLE_ALOCA]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1207  // CHECK: %[[LOAD_GEP_DTYPE_BADDR:.*]] = llvm.load %[[GEP_DTYPE_BADDR]] : !llvm.ptr -> !llvm.ptr1208  // CHECK: %[[LOAD_NESTED_DTYPE:.*]] = llvm.getelementptr %[[LOAD_GEP_DTYPE_BADDR]][0, 6] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY:!llvm.struct<"_QFRecTy", \(f32, struct<\(ptr, i64, i32, i8, i8, i8, i8\)>, array<10 x i32>, f32, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32, struct<"_QFRecTy2", \(f32, array<10 x i32>, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32\)>\)>]]1209  %2 = fir.coordinate_of %1, nest : (!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>) -> !fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>1210  // CHECK: %[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER:.*]] = llvm.getelementptr %[[LOAD_NESTED_DTYPE]][0, 2] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY2:!llvm.struct<"_QFRecTy2", \(f32, array<10 x i32>, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32\)>]]1211  %3 = fir.coordinate_of %2, array_k : (!fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1212  // CHECK: %[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER_BADDR:.*]] = llvm.getelementptr %[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY2:!llvm.struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>]]1213  %4 = fir.box_offset %3 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1214  // CHECK: %[[MAP_NESTED_MEMBER_BADDR:.*]] = omp.map.info var_ptr(%[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER_BADDR]] : !llvm.ptr) bounds(%[[BOUNDS]]) -> !llvm.ptr1215  %5 = omp.map.info var_ptr(%3 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.array<?xi32>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%4 : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%0) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1216  // CHECK: %[[MAP_NESTED_MEMBER_DESC:.*]] = omp.map.info var_ptr(%[[GEP_NESTED_DTYPE_ALLOCATABLE_MEMBER]] : !llvm.ptr, [[DESC_TY2]]) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1217  %6 = omp.map.info var_ptr(%3 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1218  // CHECK: "llvm.intr.memcpy"(%[[DTYPE_ALLOCATABLE_ALOCA_2]], %[[ARG_0]], {{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()1219  // CHECK: %[[GEP_DTYPE_BADDR:.*]] = llvm.getelementptr %[[DTYPE_ALLOCATABLE_ALOCA_2]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1220  // CHECK: %[[LOAD_GEP_DTYPE_BADDR:.*]] = llvm.load %[[GEP_DTYPE_BADDR]] : !llvm.ptr -> !llvm.ptr1221  %7 = fir.load %arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>1222  // CHECK: %[[LOAD_NESTED_DTYPE:.*]] = llvm.getelementptr %[[LOAD_GEP_DTYPE_BADDR]][0, 6] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY]]1223  %8 = fir.coordinate_of %7, nest : (!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>) -> !fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>1224  // CHECK: %[[NESTED_DTYPE_REGULAR_MEMBER_GEP:.*]] = llvm.getelementptr %[[LOAD_NESTED_DTYPE]][0, 3] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY2]]1225  %9 = fir.coordinate_of %8, k : (!fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) -> !fir.ref<i32>1226  // CHECK: %[[MAP_REGULAR_NESTED_MEMBER:.*]] = omp.map.info var_ptr(%[[NESTED_DTYPE_REGULAR_MEMBER_GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1227  %10 = omp.map.info var_ptr(%9 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32>1228  // CHECK: %[[DTYPE_BADDR_GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY]]1229  %11 = fir.box_offset %arg0 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>1230  // CHECK: %[[MAP_PARENT_BADDR:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[REC_TY]]) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[DTYPE_BADDR_GEP]] : !llvm.ptr) -> !llvm.ptr1231  %12 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>, !fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%11 : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>) -> !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>1232  // CHECK: %[[MAP_PARENT_DESC:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[DESC_TY]]) map_clauses(tofrom) capture(ByRef) members(%[[MAP_PARENT_BADDR]], %[[MAP_NESTED_MEMBER_DESC]], %[[MAP_NESTED_MEMBER_BADDR]], %[[MAP_REGULAR_NESTED_MEMBER]] : [0], [0, 6, 2], [0, 6, 2, 0], [0, 6, 3] : !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.ptr1233  %13 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>, !fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>) map_clauses(tofrom) capture(ByRef) members(%12, %6, %5, %10 : [0], [0,6,2], [0,6,2,0], [0,6,3] : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>) -> !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>1234  // CHECK: omp.target map_entries(%[[MAP_PARENT_BADDR]] -> %[[ARG_1:.*]], %[[MAP_NESTED_MEMBER_DESC]] -> %[[ARG_2:.*]], %[[MAP_NESTED_MEMBER_BADDR]] -> %[[ARG_3:.*]], %[[MAP_REGULAR_NESTED_MEMBER]] -> %[[ARG_4:.*]], %[[MAP_PARENT_DESC]] -> %[[ARG_5:.*]] : !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) {1235  omp.target map_entries(%12 -> %arg1, %6 -> %arg2, %5 -> %arg3, %10 -> %arg4, %13 -> %arg5 : !fir.llvm_ptr<!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<i32>, !fir.ref<!fir.box<!fir.heap<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>>>) {1236    omp.terminator1237  }1238  return1239}1240 1241// -----1242 1243// CHECK-LABEL:  llvm.func @map_nested_dtype_alloca_mem21244// CHECK-SAME:   %[[ARG_0:.*]]: !llvm.ptr)1245func.func @map_nested_dtype_alloca_mem2(%arg0 : !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>) {1246  %c4 = arith.constant 4 : index1247  %c1 = arith.constant 1 : index1248  %c2 = arith.constant 2 : index1249  %c0 = arith.constant 0 : index1250  %c6 = arith.constant 6 : index1251  // CHECK: %[[BOUNDS:.*]] = omp.map.bounds lower_bound({{.*}}) upper_bound({{.*}}) extent({{.*}}) stride({{.*}}) start_idx({{.*}}) {stride_in_bytes = true}1252  %0 = omp.map.bounds lower_bound(%c0 : index) upper_bound(%c4 : index) extent(%c4 : index) stride(%c1 : index) start_idx(%c0 : index) {stride_in_bytes = true}1253  // CHECK: %[[NESTED_DTYPE_MEMBER_GEP:.*]] = llvm.getelementptr %[[ARG_0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, [[REC_TY:!llvm.struct<"_QFRecTy", \(f32, struct<\(ptr, i64, i32, i8, i8, i8, i8\)>, array<10 x i32>, f32, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32, struct<"_QFRecTy2", \(f32, array<10 x i32>, struct<\(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>\)>, i32\)>\)>]]1254  %1 = fir.coordinate_of %arg0, nest : (!fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>) -> !fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>1255  // CHECK: %[[NESTED_ALLOCATABLE_MEMBER_GEP:.*]] = llvm.getelementptr %[[NESTED_DTYPE_MEMBER_GEP]][0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFRecTy2", (f32, array<10 x i32>, struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>, i32)>1256  %2 = fir.coordinate_of %1, array_k : (!fir.ref<!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1257  // CHECK: %[[NESTED_ALLOCATABLE_MEMBER_BADDR_GEP:.*]] = llvm.getelementptr %[[NESTED_ALLOCATABLE_MEMBER_GEP]][0, 0] : (!llvm.ptr) -> !llvm.ptr, [[DESC_TY2]]1258  %3 = fir.box_offset %2 base_addr : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1259  // CHECK: %[[MAP_NESTED_ALLOCATABLE_MEMBER_BADDR:.*]] = omp.map.info var_ptr(%[[NESTED_ALLOCATABLE_MEMBER_GEP]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%[[NESTED_ALLOCATABLE_MEMBER_BADDR_GEP]] : !llvm.ptr) bounds(%[[BOUNDS]]) -> !llvm.ptr1260  %4 = omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.array<?xi32>) map_clauses(tofrom) capture(ByRef) var_ptr_ptr(%3 : !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) bounds(%0) -> !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>1261  // CHECK: %[[MAP_NESTED_ALLOCATABLE_MEMBER_DESC:.*]] = omp.map.info var_ptr(%[[NESTED_ALLOCATABLE_MEMBER_GEP]] : !llvm.ptr, [[DESC_TY2]]) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr1262  %5 = omp.map.info var_ptr(%2 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.box<!fir.heap<!fir.array<?xi32>>>) map_clauses(tofrom) capture(ByRef) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>1263  // CHECK: %[[MAP_PARENT:.*]] = omp.map.info var_ptr(%[[ARG_0]] : !llvm.ptr, [[REC_TY]]) map_clauses(tofrom) capture(ByRef) members(%[[MAP_NESTED_ALLOCATABLE_MEMBER_DESC]], %[[MAP_NESTED_ALLOCATABLE_MEMBER_BADDR]] : [6, 2], [6, 2, 0] : !llvm.ptr, !llvm.ptr) -> !llvm.ptr {partial_map = true}1264  %6 = omp.map.info var_ptr(%arg0 : !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>, !fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>) map_clauses(tofrom) capture(ByRef) members(%5, %4 : [6,2], [6,2,0] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>) -> !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>> {partial_map = true}1265  // CHECK: omp.target map_entries(%[[MAP_NESTED_ALLOCATABLE_MEMBER_DESC]] -> %[[ARG_1:.*]], %[[MAP_NESTED_ALLOCATABLE_MEMBER_BADDR]] -> %[[ARG_2:.*]], %[[MAP_PARENT]] -> %[[ARG_3:.*]] : !llvm.ptr, !llvm.ptr, !llvm.ptr) {1266  omp.target map_entries(%5 -> %arg1, %4 -> %arg2, %6 -> %arg3 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.llvm_ptr<!fir.ref<!fir.array<?xi32>>>, !fir.ref<!fir.type<_QFRecTy{i:f32,scalar:!fir.box<!fir.heap<i32>>,array_i:!fir.array<10xi32>,j:f32,array_j:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32,nest:!fir.type<_QFRecTy2{i:f32,array_i:!fir.array<10xi32>,array_k:!fir.box<!fir.heap<!fir.array<?xi32>>>,k:i32}>}>>) {1267    omp.terminator1268  }1269  return1270}1271 1272// -----1273 1274// CHECK-LABEL:   omp.declare_mapper @my_mapper : !llvm.struct<"_QFdeclare_mapperTmy_type", (i32)> {1275omp.declare_mapper @my_mapper : !fir.type<_QFdeclare_mapperTmy_type{data:i32}> {1276// CHECK:         ^bb0(%[[VAL_0:.*]]: !llvm.ptr):1277^bb0(%0: !fir.ref<!fir.type<_QFdeclare_mapperTmy_type{data:i32}>>):1278// CHECK:           %[[VAL_2:.*]] = llvm.getelementptr %[[VAL_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFdeclare_mapperTmy_type", (i32)>1279  %2 = fir.coordinate_of %0, data : (!fir.ref<!fir.type<_QFdeclare_mapperTmy_type{data:i32}>>) -> !fir.ref<i32>1280// CHECK:           %[[VAL_3:.*]] = omp.map.info var_ptr(%[[VAL_2]] : !llvm.ptr, i32) map_clauses(tofrom) capture(ByRef) -> !llvm.ptr {name = "var%[[VAL_4:.*]]"}1281  %3 = omp.map.info var_ptr(%2 : !fir.ref<i32>, i32) map_clauses(tofrom) capture(ByRef) -> !fir.ref<i32> {name = "var%data"}1282// CHECK:           %[[VAL_5:.*]] = omp.map.info var_ptr(%[[VAL_0]] : !llvm.ptr, !llvm.struct<"_QFdeclare_mapperTmy_type", (i32)>) map_clauses(tofrom) capture(ByRef) members(%[[VAL_3]] : [0] : !llvm.ptr) -> !llvm.ptr {name = "var", partial_map = true}1283  %4 = omp.map.info var_ptr(%0 : !fir.ref<!fir.type<_QFdeclare_mapperTmy_type{data:i32}>>, !fir.type<_QFdeclare_mapperTmy_type{data:i32}>) map_clauses(tofrom) capture(ByRef) members(%3 : [0] : !fir.ref<i32>) -> !fir.ref<!fir.type<_QFdeclare_mapperTmy_type{data:i32}>> {name = "var", partial_map = true}1284// CHECK:           omp.declare_mapper.info map_entries(%[[VAL_5]], %[[VAL_3]] : !llvm.ptr, !llvm.ptr)1285  omp.declare_mapper.info map_entries(%4, %3 : !fir.ref<!fir.type<_QFdeclare_mapperTmy_type{data:i32}>>, !fir.ref<i32>)1286// CHECK:         }1287}1288 1289// -----1290omp.private {type = firstprivate} @boxchar_privatizer : !fir.boxchar<1> copy {1291  ^bb0(%arg0: !fir.boxchar<1>, %arg1: !fir.boxchar<1>):1292    omp.yield(%arg1 : !fir.boxchar<1>)1293}1294 1295func.func @map_privatized_boxchar(%arg0 : !fir.boxchar<1>) {1296    %0 = fir.alloca !fir.boxchar<1>1297    fir.store %arg0 to %0 : !fir.ref<!fir.boxchar<1>>1298    %7 = fir.box_offset %0 base_addr : (!fir.ref<!fir.boxchar<1>>) -> !fir.llvm_ptr<!fir.ref<!fir.char<1,?>>>1299    %8 = omp.map.info var_ptr(%0 : !fir.ref<!fir.boxchar<1>>, !fir.char<1,?>) map_clauses(implicit, to) capture(ByRef) var_ptr_ptr(%7 : !fir.llvm_ptr<!fir.ref<!fir.char<1,?>>>) -> !fir.ref<!fir.boxchar<1>>1300    %9 = omp.map.info var_ptr(%0 : !fir.ref<!fir.boxchar<1>>, !fir.boxchar<1>) map_clauses(to) capture(ByRef) members(%8 : [0] : !fir.ref<!fir.boxchar<1>>) -> !fir.ref<!fir.boxchar<1>>1301    omp.target map_entries(%9 -> %arg1, %8 -> %arg2 : !fir.ref<!fir.boxchar<1>>, !fir.ref<!fir.boxchar<1>>) private(@boxchar_privatizer %arg0 -> %arg3 [map_idx=0] : !fir.boxchar<1>) {1302      omp.terminator1303    }1304    return1305}1306 1307// CHECK-LABEL: llvm.func @map_privatized_boxchar(1308// CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(ptr, i64)>) {1309// CHECK: %[[BOXCHAR_ALLOCA:.*]] = llvm.alloca {{.*}} x !llvm.struct<(ptr, i64)> : (i64) -> !llvm.ptr1310// CHECK: llvm.store %[[ARG0]], %[[BOXCHAR_ALLOCA]] : !llvm.struct<(ptr, i64)>, !llvm.ptr1311// CHECK: %[[BASE_ADDR:.*]] = llvm.getelementptr %[[BOXCHAR_ALLOCA]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64)>1312// CHECK: %[[MAP_BASE_ADDR:.*]] = omp.map.info var_ptr(%[[BOXCHAR_ALLOCA]] : !llvm.ptr, i8) map_clauses(implicit, to) capture(ByRef) var_ptr_ptr(%[[BASE_ADDR]] : !llvm.ptr) -> !llvm.ptr1313// CHECK: %[[MAP_BOXCHAR:.*]] = omp.map.info var_ptr(%[[BOXCHAR_ALLOCA]] : !llvm.ptr, !llvm.struct<(ptr, i64)>) map_clauses(to) capture(ByRef) members(%[[MAP_BASE_ADDR]] : [0] : !llvm.ptr) -> !llvm.ptr1314// CHECK: omp.target map_entries(%[[MAP_BOXCHAR]] -> %arg1, %[[MAP_BASE_ADDR]] -> %arg2 : !llvm.ptr, !llvm.ptr) private(@boxchar_privatizer %[[ARG0]] -> %arg3 [map_idx=0] : !llvm.struct<(ptr, i64)>) {1315