! This test checks the lowering of the OpenMP `declare simd` directive with
! different clauses (e.g. aligned, linear, simdlen). It also verifies that
! the `omp.declare_simd` operation is emitted after the function prologue,
! since the directive requires access to function arguments.

! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=52 %s -o - | FileCheck %s
! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=60 %s -o - | FileCheck %s
! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-version=60 -cpp -DOMP_60 %s -o - | FileCheck %s

subroutine declare_simd_no_clause()
#ifdef OMP_60
!$omp declare_simd
#else
!$omp declare simd
#endif
end subroutine declare_simd_no_clause

! CHECK-LABEL: func.func @_QPdeclare_simd_no_clause()
! CHECK: omp.declare_simd{{$}}
! CHECK: return

subroutine declare_simd_aligned(x, y, n, i)
#ifdef OMP_60
!$omp declare_simd aligned(x, y : 64)
#else
!$omp declare simd aligned(x, y : 64)
#endif
  real(8), pointer, intent(inout) :: x(:)
  real(8), pointer, intent(in)    :: y(:)
  integer, intent(in) :: n, i
  if (i <= n) x(i) = x(i) + y(i)
end subroutine declare_simd_aligned

! CHECK-LABEL: func.func @_QPdeclare_simd_aligned(
! CHECK: %[[SCOPE_A:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[I_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[N_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[X_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 1 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK: %[[Y_A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE_A]] arg 2 {{.*pointer.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK: omp.declare_simd aligned(%[[X_A]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64,
! CHECK-SAME:                    %[[Y_A]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64){{$}}
! CHECK: return

subroutine declare_simd_linear(x, y, n, i)
#ifdef OMP_60
!$omp declare_simd linear(i)
#else
!$omp declare simd linear(i)
#endif
  real(8), pointer, intent(inout) :: x(:)
  real(8), pointer, intent(in)    :: y(:)
  integer, intent(in) :: n, i
  if (i <= n) x(i) = x(i) + y(i)
end subroutine  declare_simd_linear

! CHECK-LABEL: func.func @_QPdeclare_simd_linear(
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[I:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: omp.declare_simd linear(ref(%[[I]]#0 : !fir.ref<i32> = %[[C1]] : i32)) {linear_var_types = [i32]}{{$}}
! CHECK: return

subroutine declare_simd_simdlen(x, y, n, i)
#ifdef OMP_60
!$omp declare_simd simdlen(8)
#else
!$omp declare simd simdlen(8)
#endif
end subroutine declare_simd_simdlen

! CHECK-LABEL: func.func @_QPdeclare_simd_simdlen(
! CHECK: %[[SCOPE_S:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: omp.declare_simd{{.*}}simdlen(8){{$}}
! CHECK-NEXT: return

subroutine declare_simd_uniform(x, y, n, i)
#ifdef OMP_60
!$omp declare_simd uniform(x, y)
#else
!$omp declare simd uniform(x, y)
#endif

  real(8), pointer, intent(inout) :: x(:)
  real(8), pointer, intent(in)    :: y(:)
  integer, intent(in) :: n, i

  if (i <= n) then
    x(i) = x(i) + y(i)
  end if
end subroutine declare_simd_uniform

! CHECK-LABEL: func.func @_QPdeclare_simd_uniform(
! CHECK-SAME: fir.bindc_name = "x"
! CHECK-SAME: fir.bindc_name = "y"
! CHECK-SAME: fir.bindc_name = "n"
! CHECK-SAME: fir.bindc_name = "i"
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[IDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 4
! CHECK: %[[NDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 3
! CHECK: %[[XDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1
! CHECK: %[[YDECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 2
! CHECK: omp.declare_simd uniform(%[[XDECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, %[[YDECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK: return

subroutine declare_simd_inbranch()
#ifdef OMP_60
!$omp declare_simd inbranch
#else
!$omp declare simd inbranch
#endif
end subroutine declare_simd_inbranch

! CHECK-LABEL: func.func @_QPdeclare_simd_inbranch()
! CHECK: omp.declare_simd inbranch{{$}}
! CHECK: return

subroutine declare_simd_notinbranch()
#ifdef OMP_60
!$omp declare_simd notinbranch
#else
!$omp declare simd notinbranch
#endif
end subroutine declare_simd_notinbranch

! CHECK-LABEL: func.func @_QPdeclare_simd_notinbranch()
! CHECK: omp.declare_simd notinbranch{{$}}
! CHECK: return

subroutine declare_simd_combined(x, y, n, i)
#ifdef OMP_60
!$omp declare_simd inbranch aligned(x, y : 64) linear(i) simdlen(8) uniform(x, y)
#else
!$omp declare simd inbranch aligned(x, y : 64) linear(i) simdlen(8) uniform(x, y)
#endif
  real(8), pointer, intent(inout) :: x(:)
  real(8), pointer, intent(in)    :: y(:)
  integer, intent(in) :: n, i

  if (i <= n) then
      x(i) = x(i) + y(i)
  end if
end subroutine declare_simd_combined

! CHECK-LABEL: func.func @_QPdeclare_simd_combined(
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>{{.*}}fir.bindc_name = "x"
! CHECK-SAME: %{{.*}}: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>{{.*}}fir.bindc_name = "y"
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}fir.bindc_name = "n"
! CHECK-SAME: %{{.*}}: !fir.ref<i32>{{.*}}fir.bindc_name = "i"
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[I_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 4 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[N_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 3 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[X_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1 {{.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK: %[[Y_DECL:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 2 {{.*}} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK: %[[C1:.*]] = arith.constant 1 : i32

! CHECK: omp.declare_simd
! CHECK-SAME: aligned(%[[X_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64,
! CHECK-SAME:         %[[Y_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>> -> 64 : i64)
! CHECK-SAME: inbranch
! CHECK-SAME: linear(ref(%[[I_DECL]]#0 : !fir.ref<i32> = %[[C1]] : i32))
! CHECK-SAME: simdlen(8)
! CHECK-SAME: uniform(%[[X_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>,
! CHECK-SAME:         %[[Y_DECL]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf64>>>>)
! CHECK-SAME: {linear_var_types = [i32]}{{$}}
! CHECK: return

subroutine declare_simd_linear_val(a, b)
#ifdef OMP_60
!$omp declare_simd linear(a : val, step(2)) linear(b : val)
#else
!$omp declare simd linear(a : val, step(2)) linear(b : val)
#endif
  integer, intent(in) :: a, b
end subroutine declare_simd_linear_val

! CHECK-LABEL: func.func @_QPdeclare_simd_linear_val(
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[A:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[B:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 2 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[C2:.*]] = arith.constant 2 : i32
! CHECK: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: omp.declare_simd linear(val(%[[A]]#0 : !fir.ref<i32> = %[[C2]] : i32), val(%[[B]]#0 : !fir.ref<i32> = %[[C1]] : i32))
! CHECK-SAME: {linear_var_types = [i32, i32]}{{$}}
! CHECK: return

subroutine declare_simd_linear_ref(x)
#ifdef OMP_60
!$omp declare_simd linear(x : ref, step(4))
#else
!$omp declare simd linear(x : ref, step(4))
#endif
  integer, allocatable, intent(inout) :: x
end subroutine declare_simd_linear_ref

! CHECK-LABEL: func.func @_QPdeclare_simd_linear_ref(
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[X:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1 {{.*}} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.dscope) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
! CHECK: %[[C4:.*]] = arith.constant 4 : i32
! CHECK: omp.declare_simd linear(ref(%[[X]]#0 : !fir.ref<!fir.box<!fir.heap<i32>>> = %[[C4]] : i32))
! CHECK-SAME: {linear_var_types = [!fir.box<!fir.heap<i32>>]}{{$}}
! CHECK: return

subroutine declare_simd_linear_uval(y)
#ifdef OMP_60
!$omp declare_simd linear(y : uval)
#else
!$omp declare simd linear(y : uval)
#endif
  integer, intent(in) :: y
end subroutine declare_simd_linear_uval

! CHECK-LABEL: func.func @_QPdeclare_simd_linear_uval(
! CHECK: %[[SCOPE:.*]] = fir.dummy_scope : !fir.dscope
! CHECK: %[[Y:.*]]:2 = hlfir.declare %{{.*}} dummy_scope %[[SCOPE]] arg 1 {{.*}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[C1:.*]] = arith.constant 1 : i32
! CHECK: omp.declare_simd linear(uval(%[[Y]]#0 : !fir.ref<i32> = %[[C1]] : i32))
! CHECK-SAME: {linear_var_types = [i32]}{{$}}
! CHECK: return