offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/oop/cce-select-type-guard-not-taken.f90

@@ -0,0 +1,91 @@
+! # Finding (fortran-oop): SELECT TYPE in a declare target procedure takes CLASS DEFAULT for mapped objects of extended types
+!
+! - toolchains and modes that fail: cce19 (CCE 19.0.0: copy, unified), cce20 (CCE 20.0.2: copy, unified), cce21 (CCE 21.0.3: copy,
+!   unified), cce21_4 (CCE 21.0.4: copy, unified); -O2
+! - build: ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm/<r>; OpenACC: ftn -h acc)
+! - failure: wrong_answer (check=fail); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `r1= 0 r2= 0 r3= -1`: the calls with an ext1 and an ext2 actual take the CLASS DEFAULT branch (oop-poly-select-type,
+!   every CCE release, both modes); a CLASS(*) dummy classifies every derived-type actual as CLASS DEFAULT (oop-unlimited-classify
+!   `r1= 0`, every CCE, both modes); with intrinsic and derived actuals of a CLASS(*) dummy CCE 19 misses only the derived-type
+!   actual (oop-unlimited-select-type `r1= 42 r2= 20 r3= 5`, expected r3= 7; CCE 20 and 21 correct). All three programs map
+!   non-polymorphic objects from the host and dispatch on them in the device procedure
+! - expected: `r1= 10 r2= 100 r3= -1` (the TYPE IS (ext1) and TYPE IS (ext2) branches run for those actuals)
+! - rule: Fortran 2018 11.1.11 (a TYPE IS guard is chosen when the dynamic type of the selector is that type); a CLASS dummy
+!   argument of a declare target procedure is not restricted by OpenMP (5.2 §1.2.6 p.19 l.1-3: the type-bound procedures accessed
+!   must be declare target; this program has none)
+! - same-compiler control: the same three calls on the host (controls/host-select-type.f90 and
+!   controls/host-class-star-select-type.f90: correct on every CCE release in both modes, results/oop/probe/controls.jsonl)
+! - other families: AFAR correct on all three programs; GCC 16.2 rejects them at compile time (a separate finding:
+!   gcc-vtab-not-marked-for-offload.f90)
+! - gate and confirmer: 18 cells, 18 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl);
+!   confirmer (results/oop/main/confirm.jsonl): compiler_bug (R20-runtime-bug) 18
+! - programs (3): oop-poly-select-type, oop-unlimited-classify, oop-unlimited-select-type (offload/engine/oop_gen.py; this file
+!   is the
+!   first one)
+! - legality: for the cce cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) (tools/campaigns/oop.py legality, results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type base_t
+    integer :: a = 0
+  end type base_t
+  type, extends(base_t) :: ext1
+    integer :: u = 0
+  end type ext1
+  type, extends(base_t) :: ext2
+    integer :: v = 0
+  end type ext2
+contains
+  subroutine bump(s)
+    !$omp declare target
+    class(base_t), intent(inout) :: s
+    select type (s)
+      type is (ext1)
+        s%u = s%u + 10
+      type is (ext2)
+        s%v = s%v + 100
+      class default
+        s%a = -1
+    end select
+  end subroutine bump
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2, r3
+  type(ext1) :: e1
+  type(ext2) :: e2
+  type(base_t) :: b0
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  !$omp target map(tofrom: e1, e2, b0)
+  call bump(e1)
+  call bump(e2)
+  call bump(b0)
+  !$omp end target
+  r1 = e1%u
+  r2 = e2%v
+  r3 = b0%a
+  ok = .true.
+  ok = ok .and. (r1 == 10)
+  ok = ok .and. (r2 == 100)
+  ok = ok .and. (r3 == -1)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0)', 'r3= ', r3
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: SELECT TYPE in a device procedure takes the CLASS DEFAULT branch for mapped objects
+! summary: A declare target subroutine with a CLASS(base_t) dummy argument and a SELECT TYPE construct, called in a target region
+! + with objects of two extended types, should run the matching TYPE IS branch. CCE 19, 20 and 21 run the CLASS DEFAULT branch for
+! + every object (the same with a CLASS(*) dummy). The same calls on the host take the right branches. AFAR runs the right branches.
+! control: oop/controls/host-select-type.f90 the same calls of the same procedure on the host
+! end site

offload/_root/data/findings/oop/cce-udr-derived-type-unsupported.f90

@@ -0,0 +1,69 @@
+! # Finding (fortran-oop): declare reduction on a derived type is rejected in target loops (Unsupported OpenMP construct)
+!
+! - toolchains and modes that fail: cce19 (CCE 19.0.0: copy, unified), cce20 (CCE 20.0.2: copy, unified), cce21 (CCE 21.0.3: copy,
+!   unified), cce21_4 (CCE 21.0.4: copy, unified); -O2
+! - build: ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm/<r>; OpenACC: ftn -h acc)
+! - failure: rejected (not_implemented); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `Unsupported OpenMP construct Calls -- $udr_i_1OOP` for every combiner and initializer form (function, subroutine,
+!   type-bound operator(+), default initialization, argmax, a parallel do inside target), every CCE release
+! - expected: compiles; `r1= 2080 r2= 4160`
+! - rule: 5.2 §5.5.11 p.139-140 (declare reduction on a derived type); the procedures it calls are declare target (§5.5.2 p.125
+!   l.25-27)
+! - other families: AFAR correct on all six (its earlier finding afar-udr-derived-type-link.f90 is a structure constructor
+!   combiner); GCC 16.2 correct on all six
+! - gate and confirmer: 48 cells, 48 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl);
+!   confirmer (results/oop/main/confirm.jsonl): unsupported (R05-unsupported) 48
+! - programs (6): oop-dreduce-function, oop-dreduce-subroutine, oop-dreduce-operator, oop-dreduce-default-init,
+!   oop-dreduce-argmax, oop-dreduce-nested (offload/engine/oop_gen.py; this file is the first one)
+! - legality: for the cce cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) (tools/campaigns/oop.py legality, results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type v2
+    integer :: x = 0, y = 0
+  end type v2
+contains
+  function vadd(a, b) result(c)
+    !$omp declare target
+    type(v2), intent(in) :: a, b
+    type(v2) :: c
+    c%x = a%x + b%x
+    c%y = a%y + b%y
+  end function vadd
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(v2) :: acc
+  integer :: i
+  !$omp declare reduction(vsum: v2: omp_out = vadd(omp_out, omp_in)) initializer(omp_priv = v2(0, 0))
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  acc = v2(0, 0)
+  !$omp target teams distribute parallel do reduction(vsum: acc)
+  do i = 1, n
+    acc = vadd(acc, v2(i, 2 * i))
+  end do
+  r1 = acc%x
+  r2 = acc%y
+  ok = .true.
+  ok = ok .and. (r1 == 2080)
+  ok = ok .and. (r2 == 4160)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: declare reduction on a derived type cannot be used in a target region
+! summary: A user-defined reduction on a derived type (declare reduction with a function, subroutine or type-bound operator
+! + combiner) used on a target teams distribute parallel do is rejected by CCE 19, 20 and 21 ('Unsupported OpenMP construct'). AFAR
+! + and GCC compile and run all six forms correctly.
+! end site

offload/_root/data/findings/oop/cce21-element-component-map-lost.f90

@@ -0,0 +1,62 @@
+! # Finding (fortran-oop): map(tofrom: vk(4)%g(3)) of a component of an array element does not reach the host (CCE 21, both modes)
+!
+! - toolchains and modes that fail: cce21 (CCE 21.0.3: copy, unified), cce21_4 (CCE 21.0.4: copy, unified); -O2
+! - build: ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm/<r>; OpenACC: ftn -h acc)
+! - failure: wrong_answer (check=fail); OMP_TARGET_OFFLOAD=mandatory
+! - observed: `r1= 0 r2= 0` on CCE 21.0.3 and 21.0.4 at HSA_XNACK=0 and 1; the same for a section vk(5)%g(3:5). The nested form
+!   vk(4)%h%c(8) is an internal compiler error on CCE 21 instead, linked to fuzz/s1-3463-cce21.f90 by the confirmer and not
+!   counted here
+! - expected: `r1= 74 r2= 74`
+! - rule: 5.2 §5.8.3 p.151 l.13; §5.8.3 p.154 exit step 1a
+! - same-compiler control: the whole element map(tofrom: vk(5)) (controls/elemsec-element.f90): correct on CCE 21 in both modes
+!   (results/oop/main/rows.part*.jsonl)
+! - other families: AFAR and GCC 16.2 correct; CCE 19 and 20 fail at HSA_XNACK=0 only
+! - gate and confirmer: 8 cells, 8 confirmed in the gate's four environments (a-d; results/oop/main/gate_reruns*.jsonl); confirmer
+!   (results/oop/main/confirm.jsonl): needs_human (R22-expected-weak) 8; R22-expected-weak means the expected value has one
+!   source, the generator's Python model; the values follow from the program's arithmetic (checked by hand), and AFAR, GCC 16.2
+!   (gfx90a), GCC 16.2 (sm_80), NVHPC 25.11, NVHPC 26.9 print them on this program
+! - programs (2): oop-elemsec-comp-element, oop-elemsec-comp-section (offload/engine/oop_gen.py; this file is the first one)
+! - legality: for the cce cells: the rules (offload.engine.rules, with the fortran-oop restrictions) and AFAR's flang front end
+!   (-fsyntax-only) and NVHPC 26.9 nvfortran (compile only) (tools/campaigns/oop.py legality, results/oop/main/legality.json)
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type dc
+    integer :: g(20) = 0
+    integer :: i = 0
+  end type dc
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(dc) :: vk(5)
+  integer :: l
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  !$omp target map(tofrom: vk(4)%g(3))
+  vk(4)%g(3) = 74
+  !$omp end target
+  r1 = vk(4)%g(3)
+  r2 = sum(vk(4)%g)
+  ok = .true.
+  ok = ok .and. (r1 == 74)
+  ok = ok .and. (r2 == 74)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop
+! site:
+! title: a component of an array element mapped tofrom does not come back (CCE 21, both memory modes)
+! summary: map(tofrom: vk(4)%g(3)), an element of a component of an element of an array of structures: the target region's write
+! + is lost on CCE 21.0.3 and 21.0.4 with separate and with unified memory. Mapping the whole element vk(5) works. AFAR and GCC are
+! + correct.
+! control: oop/controls/elemsec-element.f90 the whole array element instead of a component of it
+! same_as: oop/cce-element-component-map-lost
+! end site

offload/_root/data/findings/oop/controls/alloccomp-comp-only.f90

@@ -0,0 +1,44 @@
+! control (fortran-oop family program oop-alloccomp-comp-only, correct on every CCE in both modes)
+! fortran-oop alloccomp/comp-only (OpenMP 5.2, free-form Fortran):
+! map(tofrom:) of the allocatable component alone
+! spec: OpenMP 5.2 §5.8.3 p.151-155 (map clause); OpenMP 5.2 §13.8 p.286 l.27-28 (other referenced
+!   elements of a mapped structure element are mapped too)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 4160
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(vec) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  allocate(x%a(n))
+  x%n = n
+  do i = 1, n
+    x%a(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: x%a)
+  do i = 1, n
+    x%a(i) = 2 * x%a(i)
+  end do
+  r1 = sum(x%a)
+  ok = .true.
+  ok = ok .and. (r1 == 4160)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/alloccomp-whole-explicit-component.f90

@@ -0,0 +1,50 @@
+! control for oop-alloccomp-whole: the same program; one change: map(tofrom: x, x%a) (the component listed) for
+! map(tofrom: x) (the component mapped by the predefined default mapper)
+! fortran-oop alloccomp/whole (OpenMP 5.2, free-form Fortran):
+! map(tofrom:) of a structure with an allocatable array component: the component's data is mapped
+!   with it (deep copy)
+! spec: OpenMP 5.2 §5.8.3 p.151 l.29-37 (components from the predefined default mapper); OpenMP 6.0 §B.5
+!   p.909 l.35-37 (5.0: mapping of allocatable and pointer components); OpenMP 5.2 §5.8.2 p.150
+!   (predefined default mapper)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 10336, r2= 256
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(vec) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  allocate(x%a(n))
+  x%n = n
+  do i = 1, n
+    x%a(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: x, x%a)
+  do i = 1, n
+    x%a(i) = 3 * x%a(i) + x%n
+  end do
+  r1 = sum(x%a)
+  r2 = x%a(n)
+  ok = .true.
+  ok = ok .and. (r1 == 10336)
+  ok = ok .and. (r2 == 256)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/alloccomp-whole.f90

@@ -0,0 +1,49 @@
+! control (fortran-oop family program oop-alloccomp-whole, correct on every CCE in both modes)
+! fortran-oop alloccomp/whole (OpenMP 5.2, free-form Fortran):
+! map(tofrom:) of a structure with an allocatable array component: the component's data is mapped
+!   with it (deep copy)
+! spec: OpenMP 5.2 §5.8.3 p.151 l.29-37 (components from the predefined default mapper); OpenMP 6.0 §B.5
+!   p.909 l.35-37 (5.0: mapping of allocatable and pointer components); OpenMP 5.2 §5.8.2 p.150
+!   (predefined default mapper)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 10336, r2= 256
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(vec) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  allocate(x%a(n))
+  x%n = n
+  do i = 1, n
+    x%a(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: x)
+  do i = 1, n
+    x%a(i) = 3 * x%a(i) + x%n
+  end do
+  r1 = sum(x%a)
+  r2 = x%a(n)
+  ok = .true.
+  ok = ok .and. (r1 == 10336)
+  ok = ok .and. (r2 == 256)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/elemsec-element.f90

@@ -0,0 +1,47 @@
+! control (fortran-oop family program oop-elemsec-element, correct on every CCE in both modes)
+! fortran-oop elemsec/element (OpenMP 5.2, free-form Fortran):
+! map(tofrom: vk(5)): one element of an array of structures
+! spec: OpenMP 5.2 §5.8.3 p.151 l.13 (structure elements and array sections are list items); §5.8.3
+!   p.157 l.21-22; OpenMP 5.2 §5.8.3 p.151-155 (map clause)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 610, r2= 40, r3= 0
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type dc
+    integer :: g(20) = 0
+    integer :: i = 0
+  end type dc
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2, r3
+  type(dc) :: vk(5)
+  integer :: l
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  !$omp target map(tofrom: vk(5))
+  do l = 1, 20
+    vk(5)%g(l) = 20 + l
+  end do
+  vk(5)%i = 40
+  !$omp end target
+  r1 = sum(vk(5)%g)
+  r2 = vk(5)%i
+  r3 = sum(vk(4)%g)
+  ok = .true.
+  ok = ok .and. (r1 == 610)
+  ok = ok .and. (r2 == 40)
+  ok = ok .and. (r3 == 0)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0)', 'r3= ', r3
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/final-local.f90

@@ -0,0 +1,64 @@
+! control for oop-assignfinal-final-dealloc: the family program oop-assignfinal-final-local (a non-allocatable local of
+! the same finalizable type; no ALLOCATE/DEALLOCATE)
+! fortran-oop assignfinal/final-local (OpenMP 5.2, free-form Fortran):
+! a local object of a finalizable type in a declare target subroutine is finalized on return (the
+!   final subroutine counts on the device)
+! spec: Fortran 2018 7.5.6.3 (when finalization occurs); OpenMP 5.2 §1.2.6 p.19 (type-bound procedures
+!   in declare target); OpenMP 5.2 §7.8.1 p.205-207 (declare target, procedures)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 64, r2= 4160
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type ft
+    integer :: v = 0
+  contains
+    final :: ft_fin
+  end type ft
+  integer :: fin_count = 0
+  !$omp declare target to(fin_count)
+contains
+  subroutine ft_fin(o)
+    !$omp declare target
+    type(ft), intent(inout) :: o
+    !$omp atomic update
+    fin_count = fin_count + 1
+  end subroutine ft_fin
+  subroutine work(k, r)
+    !$omp declare target
+    integer, intent(in) :: k
+    integer, intent(out) :: r
+    type(ft) :: o
+    o%v = k
+    r = 2 * o%v
+  end subroutine work
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  integer :: res(n), i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  fin_count = 0
+  !$omp target update to(fin_count)
+  !$omp target teams distribute parallel do map(tofrom: res)
+  do i = 1, n
+    call work(i, res(i))
+  end do
+  !$omp target update from(fin_count)
+  r1 = fin_count
+  r2 = sum(res)
+  ok = .true.
+  ok = ok .and. (r1 == 64)
+  ok = ok .and. (r2 == 4160)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/host-class-star-select-type.f90

@@ -0,0 +1,58 @@
+! control for oop-unlimited-classify: the same calls on the host (one change: no target construct)
+! fortran-oop unlimited/classify (OpenMP 5.2, free-form Fortran):
+! a CLASS(*) function classifying array elements of two derived types in a target teams distribute
+!   parallel do
+! spec: OpenMP 5.2 §7.8.1 p.205-207 (declare target, procedures); OpenMP 5.2 §5.3 p.107 l.17-19 (SELECT
+!   TYPE in OpenMP regions); Fortran 2018 11.1.11 (SELECT TYPE)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 320
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type pt
+    integer :: a = 0
+  end type pt
+  type qt
+    integer :: b = 0
+  end type qt
+contains
+  integer function code_of(x)
+    !$omp declare target
+    class(*), intent(in) :: x
+    select type (x)
+      type is (integer)
+        code_of = 1
+      type is (pt)
+        code_of = 2
+      type is (qt)
+        code_of = 3
+      class default
+        code_of = 0
+    end select
+  end function code_of
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(pt) :: ps(n)
+  type(qt) :: qs(n)
+  integer :: i, tot
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  tot = 0
+  do i = 1, n
+    tot = tot + code_of(ps(i)) + code_of(qs(i))
+  end do
+  r1 = tot
+  ok = .true.
+  ok = ok .and. (r1 == 320)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/host-firstprivate-defined-assignment.f90

@@ -0,0 +1,54 @@
+! control for oop-assignfinal-firstprivate: the same firstprivate(x) on a host parallel construct (one change: parallel for target)
+! fortran-oop assignfinal/firstprivate (OpenMP 5.2, free-form Fortran):
+! firstprivate(x) on a target construct initializes the new list item as if by the type-bound
+!   defined assignment
+! spec: OpenMP 5.2 §5.4.4 p.113 l.3-6 (firstprivate initialization by a compatible type-bound defined
+!   assignment); OpenMP 5.2 §1.2.6 p.19 l.1-3 (type-bound procedures accessed in a target region
+!   appear in a declare target directive)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 1, r2= 5
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type ct
+    integer :: v = 0
+    integer :: copies = 0
+  contains
+    procedure :: asg => ct_asg
+    generic :: assignment(=) => asg
+  end type ct
+contains
+  subroutine ct_asg(a, b)
+    !$omp declare target
+    class(ct), intent(inout) :: a
+    class(ct), intent(in) :: b
+    a%v = b%v
+    a%copies = b%copies + 1
+  end subroutine ct_asg
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(ct) :: x
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  x%v = 5
+  x%copies = 0
+  !$omp parallel firstprivate(x) num_threads(1)
+  r1 = x%copies
+  r2 = x%v
+  !$omp end parallel
+  ok = .true.
+  ok = ok .and. (r1 == 1)
+  ok = ok .and. (r2 == 5)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/host-lastprivate-defined-assignment.f90

@@ -0,0 +1,58 @@
+! control for oop-assignfinal-lastprivate: the same parallel do lastprivate(w) on the host (one change: no enclosing target)
+! fortran-oop assignfinal/lastprivate (OpenMP 5.2, free-form Fortran):
+! lastprivate(w) of a parallel do in a target region: the original is updated as if by the
+!   type-bound defined assignment
+! spec: OpenMP 5.2 §5.4.5 p.115 l.24-25 (lastprivate update by a type-bound defined assignment); OpenMP
+!   5.2 §1.2.6 p.19 l.1-3 (type-bound procedures accessed in a target region appear in a declare
+!   target directive)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 64, r2= 1
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type ct
+    integer :: v = 0
+    integer :: copies = 0
+  contains
+    procedure :: asg => ct_asg
+    generic :: assignment(=) => asg
+  end type ct
+contains
+  subroutine ct_asg(a, b)
+    !$omp declare target
+    class(ct), intent(inout) :: a
+    class(ct), intent(in) :: b
+    a%v = b%v
+    a%copies = b%copies + 1
+  end subroutine ct_asg
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(ct) :: w
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  w%v = -1
+  w%copies = 0
+  !$omp parallel do lastprivate(w)
+  do i = 1, n
+    w%v = i
+    w%copies = 0
+  end do
+  r1 = w%v
+  r2 = w%copies
+  ok = .true.
+  ok = ok .and. (r1 == 64)
+  ok = ok .and. (r2 == 1)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop