offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fuzz/1749-cce20.f90

@@ -0,0 +1,34 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1749 (fuzz-1).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce20/afar) checksum=63)
+! observed: device checksum=3 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: cce21
+program fuzz_prog
+  use omp_lib, only: omp_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 48, m = 8
+  integer :: i, j, r1a
+  integer(8) :: cs
+  r1a = 2
+  ! fuzz: kernels
+  !$omp target parallel map(tofrom: r1a)
+    if (omp_get_thread_num() == 0) then
+      do i = 1, n, 2
+        r1a = ior(r1a, i)
+      end do
+    end if
+  !$omp end target parallel
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn -fopenmp: a sequential DO loop executed by one thread of a target parallel region runs only some of its iterations
+! + (-O2)
+! same_as: cce19-target-parallel-guarded-loop
+! end site

offload/_root/data/findings/fuzz/1936-afar.f90

@@ -0,0 +1,61 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1936 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar) checksum=2147483504)
+! observed: device checksum=129 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 does not implement a feature the
+!   program uses (NVFORTRAN-F-1196-OpenMP - omp critical is not supported in GPU
+!   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.
+module fuzz_mod
+  implicit none
+contains
+  integer function g1(x)
+    !$omp declare target
+    integer, intent(in) :: x
+    g1 = mod(ior(merge(4, x, x /= 4), 4), 97)
+  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 = 100, m = 8
+  integer, allocatable :: ia(:)
+  integer :: ib(n)
+  integer :: i, j, r1a
+  logical :: lt
+  integer(8) :: cs
+  allocate(ia(n))
+  do i = 1, n
+    ia(i) = mod(i * 4 + 30, 211) - 80
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 58 + 12, 97) - 31
+  end do
+  r1a = 15
+  lt = .true.
+  ! fuzz: kernels
+  !$omp target map(tofrom: r1a)
+    !$omp parallel
+      !$omp do
+      do i = 1, n
+        do j = m, 1, -1
+          !$omp critical
+          r1a = ieor(r1a, ((ib((mod(((j * 1) + 2), n) + 1)) + ib(32)) - ia(i)))
+          !$omp end critical
+        end do
+      end do
+      !$omp end do
+    !$omp end parallel
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: amdflang: an unnamed critical in a target parallel do does not exclude other threads (lost updates)
+! same_as: catalog/afar-flang-critical-target-parallel-wrong
+! end site

offload/_root/data/findings/fuzz/1978-cce19.f90

@@ -0,0 +1,41 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1978 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce20/cce21) checksum=1879642524)
+! 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.
+program fuzz_prog
+  implicit none
+  integer, parameter :: n = 24, m = 5
+  integer :: o1(n)
+  integer :: i, j, jj, acc1
+  integer(8) :: cs
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target map(always, from: o1) defaultmap(firstprivate: aggregate) private(acc1, jj)
+  do i = n, 1, -1
+    acc1 = 0
+    o1(i) = i
+  end do
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1(i), 8), 2147483629_8)
+  end do
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! spec (requirement): explicit data-environment attribute clauses on a target construct determine the attributes of the
+!   variables they name, and the implicit rules, including defaultmap, apply only to the variables that no explicit clause names,
+!   so map(always, from: o1) copies the device array back whatever defaultmap(firstprivate: aggregate) says.
+! "When specified, explicit data-environment attribute clauses on target directives determine the attributes for variables
+!   referenced in a target construct." (5.2 §5.8.1 p.148 l.2-3)
+! "If a defaultmap clause is present for the category of the variable and specifies an implicit behavior other than default, the
+!   data-mapping or data-sharing attribute is determined by that clause." (5.2 §5.8.1 p.148 l.18-20)
+! spec (this program): o1 is mapped explicitly with map(always, from: o1) and defaultmap(firstprivate: aggregate) must not
+!   change that; CCE 19 returns checksum 0 instead of the host's 1879642524.
+! site:
+! title: An array mapped always, from next to defaultmap(firstprivate: aggregate) is not copied back (fuzz seed 1978)
+! end site

offload/_root/data/findings/fuzz/2014-cce19.f90

@@ -0,0 +1,46 @@
+! Minimized by compliance.fuzz_min from fuzz seed 2014 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce19/afar) checksum=0)
+! observed: device checksum=1255704643 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
+program fuzz_prog
+  use omp_lib, only: omp_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 100, m = 8
+  integer, allocatable :: ib(:)
+  integer :: o1(n)
+  integer :: i, j, r1a
+  integer(8) :: cs
+  allocate(ib(n))
+  do i = 1, n
+    ib(i) = mod(i * 18 + 43, 97) - 44
+  end do
+  o1 = 0
+  r1a = -1
+  ! fuzz: kernels
+  !$omp target map(tofrom: r1a)
+    !$omp parallel
+      if (omp_get_thread_num() == 0) then
+        do i = n, 1, -1
+          r1a = r1a * 0
+        end do
+      end if
+    !$omp end parallel
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(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: ftn -fopenmp: a sequential DO loop executed by one thread of a target parallel region runs only some of its iterations
+! + (-O2)
+! same_as: cce19-target-parallel-guarded-loop
+! end site

offload/_root/data/findings/fuzz/2224-cce19.f90

@@ -0,0 +1,30 @@
+! Minimized by compliance.fuzz_min from fuzz seed 2224 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "unhandled construct type" (v_openmp.c, line 7617, version <v>))
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "unhandled construct type" (/workspace/crayftn/pdgcs/v_openmp.c,
+!   line 7617, 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 = 32, m = 2
+  integer :: i, j
+  integer(8) :: cs
+  ! fuzz: kernels
+  !$omp target
+    !$omp masked
+    !$omp end masked
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn/craycc: constructs documented as unsupported in offload regions (single, masked, task, ordered, scan) give internal
+! + compiler errors or device link failures instead of a diagnostic
+! same_as: cce19-target-parallel-single-ice
+! end site

offload/_root/data/findings/fuzz/2334-cce19.f90

@@ -0,0 +1,57 @@
+! Minimized by compliance.fuzz_min from fuzz seed 2334 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "Couldn't find an atomic update statement" (v_mt_translate_atomic.c, line 1703,
+!   version <v>))
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "Couldn't find an atomic update statement"
+!   (/workspace/crayftn/pdgcs/v_mt_translate_atomic.c, line 1703, version cc4d36e4ff3377d4
+! 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
+  integer function g1(x)
+    !$omp declare target
+    integer, intent(in) :: x
+    g1 = mod(mod(merge(1, x, 1 > x), 13), 97)
+  end function g1
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_get_thread_num, omp_is_initial_device
+  use fuzz_mod, only: g1
+  implicit none
+  integer, parameter :: n = 100, m = 5
+  integer :: i, j, r1b
+  integer(8) :: cs
+  r1b = -1
+  ! fuzz: kernels
+  !$omp target
+    !$omp do
+    do i = 1, n
+      !$omp atomic
+      r1b = r1b * merge((-1), 1, mod(11, 13) == 0)
+    end do
+    !$omp end do
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1b, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn: internal compiler error "Couldn't find an atomic update statement" for an atomic update whose factor folds to a
+! + constant
+! control: ../vendor/checks/src/fuzz/control/fuzz-2334-cce19-control.f90 the factor depends on i: merge(-1, 1, mod(i, 13) == 0)
+! + (seven sign
+! + changes, r1b = 1)
+! end site
+! spec (requirement): an atomic update statement of the form x = x operator expr, where operator is one of the listed operators
+!   (including *) and expr is any scalar expression, is a legal update-atomic structured block; a constant-valued expr is no
+!   exception.
+! "x   =   x operator expr" (5.2 §4.3.1.3 p.81 l.12)
+! "expr is a scalar expression." (5.2 §4.3.1.3 p.79 l.23)
+! spec (this program): !$omp atomic with r1b = r1b * merge((-1), 1, mod(11, 13) == 0) is an x = x operator expr update whose
+!   scalar factor folds to the constant 1; CCE 19, 20 and 21 stop with an internal compiler error (Couldn't find an atomic update
+!   statement), while the same statement with a factor that depends on i compiles.

offload/_root/data/findings/fuzz/536-cce19.f90

@@ -0,0 +1,38 @@
+! Minimized by compliance.fuzz_min from fuzz seed 536 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (cce19/afar) checksum=716289326)
+! observed: device checksum=820542974 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
+program fuzz_prog
+  use omp_lib, only: omp_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 48, m = 8
+  integer, allocatable :: o1(:)
+  integer :: i, j
+  integer(8) :: cs
+  allocate(o1(n))
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target parallel
+    if (omp_get_thread_num() == 0) then
+      do i = 1, n
+        o1(i) = i
+      end do
+    end if
+  !$omp end target parallel
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(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: ftn -fopenmp: a sequential DO loop executed by one thread of a target parallel region runs only some of its iterations
+! + (-O2)
+! same_as: cce19-target-parallel-guarded-loop
+! end site

offload/_root/data/findings/fuzz/591-cce19.f90

@@ -0,0 +1,54 @@
+! Minimized by compliance.fuzz_min from fuzz seed 591 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "Unhandled contexts must be fixed!!!)
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "Unhandled contexts must be fixed!!!
+! 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
+  implicit none
+  integer, parameter :: n = 128, m = 8
+  integer :: o1(n, m)
+  integer :: i, j, lp1, t1
+  integer(8) :: cs
+  o1 = 0
+  lp1 = 0
+  ! fuzz: kernels
+  !$omp target
+    !$omp teams distribute simd lastprivate(lp1) private(t1) nontemporal(o1)
+    do i = n, 1, -1
+      do j = 1, m
+        t1 = 0
+        lp1 = 0
+      end do
+    end do
+    !$omp end teams distribute simd
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(lp1, 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: ftn: internal compiler error "Unhandled contexts must be fixed!!!" for teams distribute simd with lastprivate, private and
+! + nontemporal
+! control: ../vendor/checks/src/fuzz/control/fuzz-591-cce19-control.f90 nontemporal(o1) removed
+! end site
+! spec (requirement): the nontemporal clause is permitted on simd (and so on a composite construct with simd as a leaf), and the
+!   lastprivate clause applies to every leaf construct that permits it; a clause on a composite construct must apply to at least
+!   one leaf construct.
+! "The nontemporal clause specifies that accesses to the storage locations to which the list items refer have low temporal
+!   locality across the iterations in which those storage locations are accessed. The list items of the nontemporal clause may
+!   also appear as list items of data-environment attribute clauses." (5.2 §10.4.1 p.236 l.21-24)
+! "The effect of the lastprivate clause is as if it is applied to all leaf constructs that permit the clause. If the parallel
+!   construct is among the constituent constructs and the list item is not also" (5.2 §17.2 p.340 l.21-22)
+! spec (this program): teams distribute simd with lastprivate(lp1), private(t1) and nontemporal(o1) is a legal composite
+!   construct; CCE 19, 20 and 21 stop with an internal compiler error (Unhandled contexts must be fixed), and compile it when
+!   nontemporal(o1) is removed.

offload/_root/data/findings/fuzz/650-afar.f90

@@ -0,0 +1,58 @@
+! Minimized by compliance.fuzz_min from fuzz seed 650 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar/cce19) checksum=649664593)
+! observed: device checksum=0 ran_on_host=0
+! also observed (reductions of this family, data/reports/fuzz5-oop-afar.md, cluster B): at HSA_XNACK=0 an
+!   explicit-shape array written in the nested parallel region, and an implicitly mapped allocatable, fault
+!   (GPU memory access fault) instead of giving a wrong value; the same program without firstprivate(i) is correct.
+! 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 = 3
+  integer, allocatable :: o1(:, :)
+  integer :: i, j
+  logical :: lt
+  integer(8) :: cs
+  allocate(o1(n, m))
+  o1 = 0
+  lt = .true.
+  ! fuzz: kernels
+  !$omp target teams distribute
+  do i = 1, n
+    !$omp parallel firstprivate(i)
+      !$omp do
+      do j = 1, m
+        o1(i, j) = i
+      end do
+      !$omp end do
+    !$omp end parallel
+  end do
+  ! 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
+! control: ../vendor/checks/src/fuzz/control/fuzz-650-afar-control.f90 firstprivate(i) removed from the parallel construct
+! end site
+! spec (requirement): a firstprivate clause gives the construct a private, initialized copy of the named list item only, and an
+!   array that a target region references and no clause names is mapped tofrom, so the writes of the worksharing loop in the
+!   parallel region reach the shared array.
+! "In addition, the new list item is initialized from the original list item that exists before the construct. The
+!   initialization of the new list item is done once for each task that references the list item in any statement in the
+!   construct. The initialization is done prior to the execution of the construct." (5.2 §5.4.4 p.112 l.11-14)
+! "If a variable is not a scalar then it is treated as if it had appeared in a map clause with a map-type of tofrom." (5.2
+!   §5.8.1 p.149 l.4-5)
+! spec (this program): parallel firstprivate(i) with a worksharing do loop that stores o1(i, j) = i, nested in the distribute
+!   loop of a target teams construct, must leave o1 filled; AFAR loses the writes (checksum 0, or a memory fault at HSA_XNACK=0),
+!   while the same program without firstprivate(i) is correct.

offload/_root/data/findings/fuzz/698-afar.f90

@@ -0,0 +1,68 @@
+! Minimized by compliance.fuzz_min from fuzz seed 698 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash: SIGABRT)
+! expected: runs to completion (the host run does)
+! : not reproducible on the current install (AFAR 24.3.0; reruns,
+!   data/vendor/README.md: held, not reproducible); kept as a record.
+! observed: device: fail crash: SIGABRT; host reference (afar/cce19) checksum=260035799
+! 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-S-0155-Unknown PROC_BIND type); 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 = 5
+  integer, allocatable :: ia(:)
+  integer, allocatable :: ib(:)
+  integer, allocatable :: ic(:, :)
+  integer :: o1(n, m)
+  integer :: i, j, r1a, r1b, hf1
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(ib(n))
+  allocate(ic(n, m))
+  do i = 1, n
+    ia(i) = mod(i * 12 + 1, 1009) - 250
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 54 + 38, 211) - 26
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 6 * j) * 33 + 24, 1009) - 451
+    end do
+  end do
+  o1 = 0
+  r1a = -11
+  r1b = 65535
+  hf1 = 0
+  ! fuzz: kernels
+  !$omp target teams map(tofrom: hf1) reduction(max: r1a) reduction(iand: r1b)
+    !$omp distribute dist_schedule(static, 2)
+    do i = 1, n
+      !$omp parallel do reduction(max: r1a) reduction(iand: r1b) num_threads(64) proc_bind(primary)
+      do j = 1, m
+        o1(i, j) = ia((mod(((j * 4) + 5), n) + 1))
+        r1a = max(r1a, 0)
+        r1b = iand(r1b, (ishft(iand(i, 1023), (-1)) + min(ic(i, (6 - j)), ic(i, (6 - j)))))
+      end do
+    end do
+  !$omp end target teams
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  cs = modulo(cs * 31_8 + int(r1b, 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=', max(hf1, 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/700-afar.f90

@@ -0,0 +1,46 @@
+! Minimized by compliance.fuzz_min from fuzz seed 700 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar/cce19) checksum=785543890)
+! observed: device checksum=1774038079 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_get_default_device, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 32, m = 3
+  integer :: o1(n, m)
+  integer :: i, j
+  logical :: lsimd
+  integer(8) :: cs
+  o1 = 0
+  lsimd = .true.
+  ! fuzz: kernels
+  !$omp target
+    !$omp teams
+      !$omp distribute
+      do i = 1, n, 2
+        !$omp parallel firstprivate(i)
+          !$omp do
+          do j = 1, m
+            o1(i, j) = j
+          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/775-cce21.f90

@@ -0,0 +1,33 @@
+! Minimized by compliance.fuzz_min from fuzz seed 775 (fuzz-1).
+! toolchain: cce21 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar/cce19) checksum=255)
+! observed: device checksum=4 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.
+program fuzz_prog
+  use omp_lib, only: omp_get_team_num, omp_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 2
+  integer :: i, j, r1a
+  integer(8) :: cs
+  r1a = 4
+  ! fuzz: kernels
+  !$omp target map(tofrom: r1a) defaultmap(tofrom: scalar)
+    if (omp_get_team_num() == 0) then
+      do i = n, 1, -1
+        r1a = ior(r1a, i)
+      end do
+    end if
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(r1a, 8), 2147483629_8)
+  print '(a,i0,a,i0)', 'RESULT checksum=', cs, ' ran_on_host=', 0
+end program fuzz_prog
+! site:
+! title: ftn: with a defaultmap clause on target, an explicitly mapped map(tofrom) scalar is not copied back, and with
+! + defaultmap(tofrom) an array in map(alloc) or map(to) is copied back
+! same_as: cce21-defaultmap-aggregate-flag
+! end site

offload/_root/data/findings/fuzz/87-afar.f90

@@ -0,0 +1,47 @@
+! Minimized by compliance.fuzz_min from fuzz seed 87 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: wrong_code
+! expected: the host reference checksum (host reference (afar) checksum=748154768)
+! observed: device checksum=0 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 = 32, m = 3
+  integer, allocatable :: o1(:, :)
+  integer :: i, j, p1
+  integer(8) :: cs
+  allocate(o1(n, m))
+  o1 = 0
+  p1 = 4
+  ! fuzz: kernels
+  !$omp target
+    !$omp teams firstprivate(p1)
+      !$omp distribute
+      do i = n, 1, -1
+        !$omp parallel firstprivate(p1)
+          !$omp do
+          do j = 1, m, 2
+            o1(i, j) = p1
+          end do
+          !$omp 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