| ! Test declare reduction with derived types that have FINAL subroutines | |
| ! and non-trivial user-defined initializers, to verify that initialization | |
| ! and finalization are generated correctly. | |
| ! | |
| ! RUN: %flang_fc1 -emit-hlfir -fopenmp %s -o - | FileCheck %s | |
| ! --------------------------------------------------------------------- | |
| ! Test 1: Simple derived type with finalizer and structure constructor init | |
| ! --------------------------------------------------------------------- | |
| module m1 | |
| implicit none | |
| type :: t | |
| integer :: x = -999 | |
| contains | |
| final :: cleanup | |
| end type t | |
| contains | |
| subroutine cleanup(this) | |
| type(t), intent(inout) :: this | |
| this%x = 0 | |
| end subroutine cleanup | |
| end module m1 | |
| ! CHECK-LABEL: omp.declare_reduction @_QQFplus_t{{.*}} byref_element_type({{.*}}) : !fir.ref<{{.*}}> | |
| ! | |
| ! -- alloc region | |
| ! CHECK: alloc { | |
| ! CHECK: %[[ALLOCA:.*]] = fir.alloca | |
| ! CHECK: omp.yield(%[[ALLOCA]] : | |
| ! | |
| ! -- init region: must store 100 (from initializer clause), not -999 (default) | |
| ! CHECK: } init { | |
| ! CHECK: ^bb0(%[[INIT_ARG0:.*]]: !fir.ref<{{.*}}>, %[[INIT_ARG1:.*]]: !fir.ref<{{.*}}>): | |
| ! CHECK: %{{.*}}:2 = hlfir.declare %[[INIT_ARG0]] {uniq_name = "omp_orig"} | |
| ! CHECK: %[[PRIV_DECL:.*]]:2 = hlfir.declare %[[INIT_ARG1]] {uniq_name = "omp_priv"} | |
| ! CHECK: %[[INIT_ADDR:.*]] = fir.address_of(@_QQro._QMm1Tt.0) | |
| ! CHECK: %[[INIT_DECL:.*]]:2 = hlfir.declare %[[INIT_ADDR]] | |
| ! CHECK: hlfir.assign %[[INIT_DECL]]#0 to %[[PRIV_DECL]]#0 | |
| ! CHECK: omp.yield(%[[INIT_ARG1]] : | |
| ! | |
| ! -- combiner region | |
| ! CHECK: } combiner { | |
| ! CHECK: ^bb0(%[[LHS:.*]]: !fir.ref<{{.*}}>, %[[RHS:.*]]: !fir.ref<{{.*}}>): | |
| ! CHECK: %{{.*}}:2 = hlfir.declare %[[RHS]] {uniq_name = "omp_in"} | |
| ! CHECK: %{{.*}}:2 = hlfir.declare %[[LHS]] {uniq_name = "omp_out"} | |
| ! CHECK: hlfir.assign %{{.*}} to %{{.*}} : i32, !fir.ref<i32> | |
| ! CHECK: omp.yield(%[[LHS]] : | |
| ! -- cleanup region: calls runtime destroy (which dispatches to the finalizer) | |
| ! CHECK: } cleanup { | |
| ! CHECK: ^bb0(%[[CLEANUP_ARG:.*]]: !fir.ref<{{.*}}>): | |
| ! CHECK: %[[BOX:.*]] = fir.embox %[[CLEANUP_ARG]] | |
| ! CHECK: %[[CONV:.*]] = fir.convert %[[BOX]] | |
| ! CHECK: fir.call @_FortranADestroy(%[[CONV]]) | |
| ! CHECK: omp.yield | |
| ! CHECK: } | |
| ! | |
| ! TODO: Test declare reduction without an initializer clause to verify | |
| ! the default constructor value (-999) is used. This requires support | |
| ! for declare reduction without an initializer clause. | |
| ! Verify the init value constant is 100 (from T(100)), not -999 (default) | |
| ! CHECK: fir.global internal @_QQro._QMm1Tt.0 constant | |
| ! CHECK: %[[C100:.*]] = arith.constant 100 : i32 | |
| ! CHECK: fir.insert_value %{{.*}}, %[[C100]], ["x", | |
| program test1 | |
| use m1 | |
| implicit none | |
| type(t) :: a | |
| !$omp declare reduction(plus_t:t: omp_out%x = omp_out%x + omp_in%x) & | |
| !$omp& initializer(omp_priv = t(100)) | |
| a = t(200) | |
| !$omp parallel reduction(plus_t:a) | |
| a%x = a%x + 1 | |
| !$omp end parallel | |
| end program test1 |