offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fuzz/b1-268-afar.f90

@@ -0,0 +1,46 @@
+! Minimized by compliance.fuzz_min from fuzz seed 268 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce19/elision) checksum=447891769)
+! observed: device checksum=603216482 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 100, m = 2
+  integer, allocatable :: o1(:, :)
+  integer :: i, j, t1
+  integer(8) :: cs
+  allocate(o1(n, m))
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target
+    !$omp teams
+      !$omp distribute
+      do i = n, 1, -1
+        !$omp parallel private(j, t1) firstprivate(i)
+          !$omp do private(t1)
+          do j = 1, m
+            t1 = 0
+            o1(i, j) = 97
+          end do
+        !$omp end parallel
+      end do
+    !$omp end teams
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang: a parallel region with firstprivate nested in a distribute loop loses the writes of its worksharing loop
+! same_as: fuzz/650-afar
+! end site

offload/_root/data/findings/fuzz/b2-183-afar.f90

@@ -0,0 +1,57 @@
+! Minimized by compliance.fuzz_min from fuzz seed 183 (fuzz-3, base group derived).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGABRT): OFFLOAD ERROR: memory access fault ... Write access to a read-only page
+! expected: RESULT checksum=0 (host reference cce19 and sequential elision; AFAR at HSA_XNACK=0 prints it)
+! observed: GPU memory access fault at HSA_XNACK=1, THP on and off (flux, idle node); agrees at HSA_XNACK=0
+! The derived types are left over (unused); hand-reduced: data/findings/afar-xnack1-atomic-min-nested-parallel.f90
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 24, m = 2
+  type :: nd_t
+  end type nd_t
+  type :: rec_t
+    type(nd_t) :: nd
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable :: o1(:, :)
+  integer :: i, j, r1a
+  integer(8) :: cs
+  allocate(o1(n, m))
+  o1 = 0
+  r1a = 7
+  ! fuzz: kernels
+  !$omp target teams distribute map(always, tofrom: r1a)
+  do i = 1, n
+    !$omp parallel do
+    do j = 1, m
+      o1(i, j) = 0
+      !$omp atomic
+      r1a = min(r1a, mod(i, n))
+    end do
+    !$omp end parallel do
+  end do
+  !$omp end target teams distribute
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang at HSA_XNACK=1: atomic min in a parallel do nested in target teams distribute with an allocatable array faults
+! + (write to a read-only page)
+! same_as: afar-xnack1-atomic-min-nested-parallel
+! end site

offload/_root/data/findings/fuzz/b2-209-cce19.f90

@@ -0,0 +1,51 @@
+! Minimized by compliance.fuzz_min from fuzz seed 209 (fuzz-3).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (elision) checksum=16)
+! observed: device checksum=0 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce20, cce21
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  implicit none
+  integer, parameter :: n = 16, m = 3
+  type :: rec_t
+  end type rec_t
+  type :: el_t
+  end type el_t
+  type(rec_t) :: dr
+  type(el_t) :: ds(n)
+  integer :: i, j, jj, lp1, acc1
+  integer(8) :: cs
+  lp1 = 0
+  ! fuzz: kernels
+  !$omp target simd lastprivate(conditional: lp1) private(acc1, jj)
+  do i = 1, n
+    acc1 = 0
+    if (mod(i, 2) == 0) lp1 = i
+  end do
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(lp1, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn: lastprivate(conditional:) on target simd does not imply map(tofrom), value lost
+! control: ../vendor/checks/src/fuzz/control/fuzz-b2-209-cce19-control.f90 lp1 also mapped explicitly: map(tofrom: lp1)
+! end site
+! spec (requirement): on a combined construct that includes target, a list item of a lastprivate clause is mapped as if with
+!   map-type tofrom, and with the conditional modifier the original list item receives the value that sequential execution of the
+!   loop would leave.
+! "If the target construct is among the constituent constructs and the list item is not the base variable or base pointer of a
+!   list item that appears in a map clause, the effect of the lastprivate clause is as if the same list item appears in a map
+!   clause with a map-type of tofrom." (5.2 §17.2 p.340 l.27-30)
+! "When the conditional modifier appears on the clause or the list item is an iteration variable of one of the associated loops,
+!   if sequential execution of the loop nest would assign a value to the list item then the original list item is assigned the
+!   value that the list item would have after sequential execution of the loop nest." (5.2 §5.4.5 p.115 l.16-19)
+! spec (this program): target simd lastprivate(conditional: lp1) implies map(tofrom: lp1), so the host must see lp1 = 16 after
+!   the loop; CCE 19, 20 and 21 return 0, and the program is correct when lp1 is also mapped explicitly with map(tofrom: lp1).

offload/_root/data/findings/fuzz/b2-213-afar.f90

@@ -0,0 +1,63 @@
+! Minimized by compliance.fuzz_min from fuzz seed 213 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGABRT)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGABRT; host reference (cce19) checksum=797202134
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 32, m = 5
+  type :: rec_t
+    integer :: a(n)
+  end type rec_t
+  type :: el_t
+  end type el_t
+  type(rec_t) :: dr
+  type(el_t) :: ds(n)
+  integer, allocatable :: o1(:, :)
+  integer :: i, j, r1a
+  integer(8) :: cs
+  allocate(o1(n, m))
+  do i = 1, n
+    dr%a(i) = mod(i * 23 + 28, 1009) - 305
+  end do
+  o1 = 0
+  r1a = 145
+  ! fuzz: kernels
+    !$omp target map(tofrom: r1a)
+      !$omp teams reduction(ieor: r1a)
+        !$omp distribute
+        do i = 1, n
+          !$omp parallel
+            !$omp do reduction(ieor: r1a)
+            do j = 1, m, 2
+              o1(i, j) = 0
+              r1a = ieor(r1a, iand(dr%a(i), 1048575))
+            end do
+          !$omp end parallel
+        end do
+      !$omp end teams
+    !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang at HSA_XNACK=1: a parallel region with a reduction (or atomic) nested in a distribute loop of a reducing teams
+! + region aborts
+! same_as: fuzz/916-afar
+! end site

offload/_root/data/findings/fuzz/b2-52-afar.f90

@@ -0,0 +1,56 @@
+! Minimized by compliance.fuzz_min from fuzz seed 52 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce19) checksum=1272193681)
+! observed: device checksum=2115128177 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64, m = 2
+  type :: nd_t
+  end type nd_t
+  type :: rec_t
+    type(nd_t) :: nd
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: o3(n, m)
+  integer :: i, j
+  integer(8) :: cs
+  o3 = 0
+  ! fuzz: kernels
+  !$omp target
+    !$omp teams
+      !$omp distribute
+      do i = 1, n
+        !$omp parallel firstprivate(i)
+          !$omp do
+          do j = m, 1, -1
+            o3(i, j) = 1009
+          end do
+          !$omp end do
+        !$omp end parallel
+      end do
+      !$omp end distribute
+    !$omp end teams
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o3(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang: a parallel region with firstprivate nested in a distribute loop loses the writes of its worksharing loop
+! same_as: fuzz/650-afar
+! end site

offload/_root/data/findings/fuzz/b2-68-afar.f90

@@ -0,0 +1,54 @@
+! Minimized by compliance.fuzz_min from fuzz seed 68 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce19) checksum=17631)
+! observed: device checksum=70431 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); NVHPC is no witness: it rejects it (NVFORTRAN-F-1243-GPU
+!   target doesn't support 'if' clauses for managing
+!   parallel region.); the check's other witness, the AFAR flang front end, is the compiler under
+!   test and is not counted; no gfortran or gcc is a legality witness.
+program fuzz_prog
+  use omp_lib, only: omp_get_default_device, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 8
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: i, j, r3a, hf3
+  logical :: lpar
+  integer(8) :: cs
+  r3a = 31
+  hf3 = 0
+  lpar = .false.
+  ! fuzz: kernels
+  !$omp target map(tofrom: hf3) map(tofrom: r3a)
+    hf3 = merge(1, 0, omp_is_initial_device())
+    !$omp parallel if(parallel: lpar)
+      !$omp loop reduction(+: r3a)
+      do i = 1, n
+        do j = m, 1, -1
+          r3a = r3a + 11
+        end do
+      end do
+      !$omp end loop
+    !$omp end parallel
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r3a, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf3, 0)
+end program fuzz_prog
+! site:
+! title: amdflang: loop reduction inside parallel if(.false.) in a target region counts the contribution more than once
+! control: ../vendor/checks/src/fuzz/control/fuzz-b2-68-afar-control.f90 lpar = .true. (the parallel region is active)
+! end site
+! spec (requirement): a parallel region whose if clause evaluates to false is executed by a team of one thread, and a reduction
+!   on the loop construct bound to it combines the threads' private copies with the original value once.
+! "if (IfClauseValue = false) then number of threads = 1;" (5.2 §10.1.1 p.226 l.27-28)
+! "At the end of a region that corresponds to a construct for which the reduction clause was specified, the original list item
+!   is updated by combining its original value with the final value of each of the private copies, using the combiner of the
+!   specified reduction-identifier." (5.2 §5.5.8 p.135 l.7-10)
+! spec (this program): parallel if(parallel: lpar) with lpar false (one thread) around loop reduction(+: r3a) in a target region
+!   adds each of the 1600 contributions once (r3a = 31 + 1600 * 11); AFAR counts the contributions four times (checksum 70431
+!   instead of 17631), and is correct with lpar true.

offload/_root/data/findings/fuzz/b2-85-cce20.f90

@@ -0,0 +1,55 @@
+! Minimized by compliance.fuzz_min from fuzz seed 85 (fuzz-3).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar) checksum=1901273453)
+! observed: device checksum=0 ran_on_host=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce19, cce21
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 48, m = 8
+  type :: rec_t
+    integer :: o1(n)
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable :: ib(:)
+  integer :: ic(n, m)
+  integer :: i, j, p1, t1
+  integer(8) :: cs
+  allocate(ib(n))
+  do i = 1, n
+    ib(i) = mod(i * 51 + 10, 101) - 15
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 8 * j) * 55 + 11, 211) - 18
+    end do
+  end do
+  dr%o1 = 0
+  p1 = -6
+  ! fuzz: kernels
+  !$omp target map(tofrom: dr%o1) map(to: ic) defaultmap(firstprivate: aggregate)
+    !$omp teams distribute private(t1)
+    do i = n, 1, -1
+      t1 = 0
+      dr%o1(i) = mod((mod((ic((mod(((i * 2) + 6), n) + 1), (mod(((i * 3) + 3), m) + 1)) + t1), 7) - &
+          & ior((2 + ib(i)), mod(p1, 7))), 1009)
+    end do
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(dr%o1(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: A minimized program with defaultmap and teams distribute computes checksum 0 on the device (fuzz seed 85)
+! control: ../vendor/checks/src/fuzz/control/fuzz-b2-85-cce20-control.f90 defaultmap(firstprivate: aggregate) removed
+! disposition: mixed rests on reading map(tofrom: dr%o1) as an explicit attribute of the structure dr; 5.2 §5.8.1 p.148 treats a
+! + reference to a structure element as a reference to the structure when implicit attributes are determined, so
+! + defaultmap(firstprivate: aggregate) may apply to dr
+! end site

offload/_root/data/findings/fuzz/b3-188-cce19.f90

@@ -0,0 +1,90 @@
+! Minimized by compliance.fuzz_min from fuzz seed 188 (fuzz-3).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "Unexpected schedule" (v_mt_translate.c, line 4112, version <v>))
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "Unexpected schedule"
+!   (/workspace/crayftn/pdgcs/v_mt_translate.c, line 4112, version cc4d36e4ff3377d45f0e6e892b5dacd82009a0ca)
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce20, cce21
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 48, m = 4
+  integer, allocatable :: ia(:)
+  integer, allocatable :: ib(:)
+  integer, allocatable :: ic(:, :)
+  integer, allocatable :: as1
+  integer, pointer :: o1(:, :)
+  integer, target :: o1t(n, m)
+  integer :: i, j, jj, p1, p2, r1a, lp1, hf1
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(ib(n))
+  allocate(ic(n, m))
+  allocate(as1)
+  o1 => o1t
+  do i = 1, n
+    ia(i) = mod(i * 42 + 2, 1009) - 210
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 5 + 50, 1009) - 327
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 1 * j) * 42 + 27, 211) - 23
+    end do
+  end do
+  as1 = 25
+  o1 = 0
+  p1 = 8
+  p2 = -7
+  r1a = 76
+  lp1 = 0
+  hf1 = 0
+  ! fuzz: kernels
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  cs = modulo(cs * 31_8 + int(lp1, 8), 2147483629_8)
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1t(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf1, 0)
+contains
+  subroutine kp1(as1, ia, ib, ic, o1, p1)
+    integer, allocatable, intent(inout) :: as1
+    integer, allocatable, intent(inout) :: ia(:)
+    integer, intent(inout) :: ib(n)
+    integer, allocatable, intent(inout) :: ic(:, :)
+    integer, intent(inout) :: o1(:, :)
+    integer, intent(in), optional :: p1
+    integer :: i, j, jj
+    !$omp target teams
+      !$omp distribute parallel do schedule(dynamic) dist_schedule(static, 16)
+      do i = 1, n
+      end do
+    !$omp end target teams
+  end subroutine kp1
+end program fuzz_prog
+! site:
+! title: ftn: internal compiler error "Unexpected schedule" for distribute parallel do schedule(dynamic) dist_schedule(static, 16)
+! control: ../vendor/checks/src/fuzz/control/fuzz-b3-188-cce19-control.f90 schedule(dynamic) removed from the distribute parallel do
+! end site
+! spec (requirement): in a composite construct each clause that is permitted on only one leaf construct applies to that leaf:
+!   schedule applies to the worksharing loop and dist_schedule to distribute, and a dynamic schedule gives each thread a chunk
+!   until none remain.
+! "Some clauses are permitted only on a single leaf construct of the combined or composite construct, in which case the effect
+!   is as if the clause is applied to that specific construct." (5.2 §17.2 p.339 l.31-33)
+! "If the kind argument is dynamic, each thread executes a chunk, then requests another chunk, until no chunks remain to be
+!   assigned. Each chunk contains chunk_size iterations, except for the chunk that contains the sequentially last iteration, which
+!   may have fewer iterations. If chunk_size is not specified, it defaults to 1." (5.2 §11.5.3 p.252 l.23-26)
+! "The dist_schedule clause specifies how iterations of associated loops of a distribute construct are divided into contiguous
+!   non-empty subsets, called chunks, and how these chunks are distributed among the teams of the league. if chunk_size is not
+!   specified, the iteration space is divided into chunks that are approximately equal in size, and at most one chunk is
+!   distributed to each initial team of the league." (5.2 §11.6.1 p.256 l.13-17)
+! spec (this program): distribute parallel do schedule(dynamic) dist_schedule(static, 16) is a legal combination; CCE 19, 20 and
+!   21 stop with an internal compiler error (Unexpected schedule), and compile it when schedule(dynamic) is removed.

offload/_root/data/findings/fuzz/b3-190-cce21.f90

@@ -0,0 +1,88 @@
+! Minimized by compliance.fuzz_min from fuzz seed 190 (fuzz-3).
+! toolchain: cce21 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGSEGV)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGSEGV; host reference (afar) checksum=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+module fuzz_mod
+  implicit none
+contains
+  integer function g1(x, y)
+    !$omp declare target
+    integer, intent(in) :: x, y
+    g1 = 0
+  end function g1
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  use fuzz_mod, only: g1
+  implicit none
+  integer, parameter :: n = 24, m = 3
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer, allocatable, target :: ia(:)
+  integer, target :: ib(n)
+  integer, allocatable :: as1
+  integer, allocatable :: o1(:, :)
+  integer :: o2(n, m)
+  integer :: i, j, jj
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(o1(n, m))
+  allocate(as1)
+  do i = 1, n
+    ia(i) = mod(i * 19 + 10, 101) - 23
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 32 + 7, 97) - 39
+  end do
+  as1 = 46
+  o1 = 0
+  o2 = 0
+  ! fuzz: kernels
+  call kp1(as1, ia, o1, dr)
+  ! fuzz: checksum
+  cs = 0
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o1(i, j), 8), 2147483629_8)
+    end do
+  end do
+  do j = 1, m
+    do i = 1, n
+      cs = modulo(cs * 31_8 + int(o2(i, j), 8), 2147483629_8)
+    end do
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+contains
+  subroutine kp1(as1, ia, o1, dr, zopt)
+    integer, intent(inout) :: as1
+    integer, intent(in) :: ia(n)
+    integer, intent(inout) :: o1(n, m)
+    type(rec_t), intent(inout) :: dr
+    integer, intent(in), optional :: zopt(:)
+    integer :: i, j, jj, t1
+    !$omp target private(t1) map(to: zopt)
+    do i = 1, n
+      do j = 1, m
+        t1 = g1((-10), as1)
+      end do
+    end do
+    !$omp end target
+  end subroutine kp1
+  subroutine kp2(ib, o2)
+    integer, intent(inout) :: ib(n)
+    integer, intent(inout) :: o2(n, m)
+    integer :: i, j, jj
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: map(to: zopt) of an absent optional dummy in an internal subroutine crashes the run (SIGSEGV)
+! control: ../vendor/checks/src/fuzz/control/fuzz-b3-190-cce21-control.f90 map(to: zopt) removed (the absent dummy is not named
+! + in a map
+! + clause)
+! same_as: catalog/afar-flang-absent-optional-target-crash
+! end site

offload/_root/data/findings/fuzz/b3-197-cce19.f90

@@ -0,0 +1,77 @@
+! Minimized by compliance.fuzz_min from fuzz seed 197 (fuzz-3).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGABRT)
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGABRT; host reference (afar) checksum=1030200169
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce20
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 16, m = 3
+  integer, target :: ib(n)
+  integer, target :: ic(n, m)
+  integer, allocatable :: as1
+  integer, allocatable :: o2(:)
+  integer, pointer :: o3(:)
+  integer, allocatable :: o4(:)
+  integer, target :: o3t(n)
+  integer :: i, j, r4a, hf4
+  integer(8) :: cs
+  allocate(o2(n))
+  allocate(o4(n))
+  allocate(as1)
+  o3 => o3t
+  do i = 1, n
+    ib(i) = mod(i * 52 + 34, 211) - 23
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 7 * j) * 58 + 25, 101) - 21
+    end do
+  end do
+  as1 = 20
+  o2 = 0
+  o3 = 0
+  o4 = 0
+  r4a = 3
+  hf4 = 0
+  ! fuzz: kernels
+  call kp1(as1, ib, ic, o2, o3, o4)
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o2(i), 8), 2147483629_8)
+  end do
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o3t(i), 8), 2147483629_8)
+  end do
+  cs = modulo(cs * 31_8 + int(r4a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o4(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', max(hf4, 0)
+contains
+  subroutine kp1(as1, ib, ic, o2, o3, o4)
+    integer, intent(inout) :: as1
+    integer, intent(inout) :: ib(:)
+    integer, intent(in) :: ic(:, :)
+    integer, intent(in) :: o2(:)
+    integer, intent(inout) :: o3(:)
+    integer, intent(inout) :: o4(:)
+    !$omp taskgroup task_reduction(+: r4a)
+      !$omp target map(tofrom: hf4) in_reduction(+: r4a)
+        hf4 = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          o4(i) = mod(iand(o3((mod(((i * 3) + 5), n) + 1)), 1023), 97)
+        end do
+      !$omp end target
+    !$omp end taskgroup
+  end subroutine kp1
+end program fuzz_prog
+! site:
+! title: ftn: a target construct with in_reduction in an internal subroutine loses the writes to an implicitly mapped dummy array
+! same_as: fuzz/b3-61-cce20
+! end site