offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fresh/cce21-combined-if-runtime-expr-loop-skipped.f90

@@ -0,0 +1,57 @@
+! # Finding (from the data/bench/fresh draft fresh-046): CCE 21 skips a target teams
+!   distribute parallel do whose if clause has no modifier and a run-time expression
+!
+! - source: data/bench/fresh/fresh-046.f90 (llvm-project issue 208698): `target teams distribute parallel
+!   do map(present, tofrom: data) if (should_offload)` with should_offload a module logical; CCE 21
+!   leaves data untouched. Neither present, target enter data nor the loop length matters
+! - compilers: CCE 21.0.3 ftn, -fopenmp -O2; MI300A HSA_XNACK 1 and 0, MI250X HSA_XNACK 0
+! - expected: b(1) 1 b(64) 64 dev 1. "For a combined or composite construct, if no
+!   directive-name-modifier is specified then the if clause applies to all constituent constructs to
+!   which an if clause can apply" (OpenMP 5.2 §3.4 p.72 l.15-18). Whether teams is one of them, 5.2
+!   does not say consistently: the if clause's directive list (§3.4 p.72 l.8-9) and the teams clause
+!   list (§10.2 p.230 l.7-8) omit it, the teams semantics (p.230 l.18-21) describe it, and 6.0 §B.3
+!   p.904 l.16 records it as a 5.1-to-5.2 change; under 5.0 the clause applies to target and parallel
+!   only. The expected output does not depend on it: on is true on the host, so the region runs on
+!   the device (dev 1), and whatever number of teams and threads results, every iteration runs once
+! - actual: b(1) 0 b(64) 0 dev -1: no iteration runs, on the device or on the host, and the program
+!   goes on without a message (every run, both memory modes, both machines). The same with an
+!   integer module variable (if (k > 0), d046-min-int.f90) and with a local logical set from it
+!   (d046-min-local.f90); if (.true.) is correct (d046-if-true.f90), and so is a local logical set
+!   from a literal (d046-if-local.f90, which the compiler can fold). Fix: if (teams: on)
+!   alone fails the same way (d046-min-teams.f90; MI300A both modes, MI250X), if (parallel: on) is
+!   correct (d046-min-parallel.f90): the teams part of the if clause is where CCE 21 goes wrong
+! - control (same compiler): if (target: on) on the same construct prints b(1) 1 b(64) 64 dev 1
+!   (data/reports/fresh-drafts/d046-min-target.f90); so do the unmodified if (on) on target teams
+!   distribute, target parallel do and target teams (d046-min-tdist.f90, d046-min-tpd.f90,
+!   d046-min-tteams.f90)
+! - other families: AFAR and CCE 19/20 print b(1) 1 b(64) 64 dev 1 (MI300A HSA_XNACK 1 and 0;
+!   MI250X); NVHPC 25.11 and 26.9 run the draft without the present modifier correctly
+!   (d046-no-present.f90, PASS; nvfortran rejects map(present, ...))
+! - legality: legal by reading (dev is written by one iteration only); an if clause without a
+!   modifier on this combined construct is also conforming under OpenMP 5.0, which HPE claims in full
+! - evidence: results/fresh-drafts/tuo-p3.jsonl, tuo2-q3.jsonl, tuo3-r*-a.jsonl, tioga/tioga-c.jsonl,
+!   tuo4-p.jsonl, tioga/tioga2.jsonl, wingtip/nv.jsonl (review)
+module ctl
+  implicit none
+  logical :: on = .true.
+end module ctl
+
+program p
+  use omp_lib, only: omp_is_initial_device
+  use ctl
+  implicit none
+  integer :: b(64), i, dev
+  b = 0
+  dev = -1
+  !$omp target teams distribute parallel do map(tofrom: b, dev) if (on)
+  do i = 1, 64
+    b(i) = i
+    if (i == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  print *, 'b(1)', b(1), 'b(64)', b(64), 'dev', dev
+end program p
+! site:
+! title: ftn: target teams distribute parallel do with if(<run-time true>) runs no iterations at all
+! control: ../vendor/checks/src/cce/control/cce21-combined-if-runtime-expr-loop-skipped-control.f90 if (target: on) instead of if
+! + (on)
+! end site

offload/_root/data/findings/fresh/nvhpc-acc-gang-worker-collapse-nested-vector-reduction-lost.f90

@@ -0,0 +1,67 @@
+! # Finding (from the data/bench/fresh draft fresh-076): NVHPC loses contributions of a gang
+!   worker collapse(2) reduction with a nested vector reduction
+!
+! - source: data/bench/fresh/fresh-076.f90 (NVIDIA developer forum topic 354721, the full program of the
+!   2025-12-16 reply). The reporter's program has no data clause for sumA on the parallel
+!   construct, which OpenACC 3.4 §2.6.2 p.42 l.1403-1409 forbids for a scalar in a loop reduction
+!   whose access is exposed to a parent parallel construct; this reproducer adds copy(sumA) and sets
+!   A = 1 so the sum is exact. With the reporter's sizes (1000 x 1000 x 100, 100 calls) the legal
+!   form ends in CUDA_ERROR_ILLEGAL_ADDRESS (data/reports/fresh-drafts/d076-copy.f90)
+! - compilers: NVHPC nvfortran 25.11 and 26.9, -acc=gpu -gpu=cc80 -O2, -gpu=mem:separate and
+!   -gpu=mem:managed; A100
+! - expected: pass 10000000.0. Each loop's reduction combines the private copies after the loop
+!   with the original var (OpenACC 3.4 §2.9.11 p.71 l.2549-2555); a reduction spanning nested
+!   loops carries the clause on each loop directive (l.2560-2562), as here; every A(i,j,k) is 1, so
+!   the sum is m*n*o = 10^7 exactly in any order
+! - actual: 9987000 to 9997000 (whole inner loops of 1000 lost; the count varies between runs), both
+!   releases, both memory modes, 12 of 12 runs
+! - control (same compiler): 10000000 with gang collapse(2) instead of gang worker collapse(2)
+!   (data/reports/fresh-drafts/d076-c-gang.f90), with the inner loop seq (d076-c-seq.f90), or with
+!   worker vector on the inner loop (d076-c-worker-vector.f90); the same nest at 64 x 64 x 4 is
+!   correct (d076-exact-small.f90)
+! - other families: CCE 19/20/21 print pass 10000000 on this program (MI300A HSA_XNACK 1 and 0;
+!   MI250X); AFAR has no Fortran OpenACC
+! - legality: legal by reading (copy(sumA) on the parallel construct; the reduction clause on both
+!   loop directives of the nest)
+! - evidence: results/fresh-drafts/wingtip/nv.jsonl, tuo2-q6.jsonl, tioga/tioga-b.jsonl (review)
+module test_mod
+contains
+subroutine test(A, sumA)
+  implicit none
+  real(kind=8) :: A(:,:,:), sumA
+  integer :: i, j, k
+!$acc parallel copy(sumA)
+!$acc loop gang worker collapse(2) reduction(+:sumA)
+  do k = 1, size(A,3)
+    do j = 1, size(A,2)
+!$acc loop vector reduction(+:sumA)
+      do i = 1, size(A,1)
+        sumA = sumA + A(i,j,k)
+      end do
+    end do
+  end do
+!$acc end parallel
+end subroutine test
+end module test_mod
+
+program main
+  use test_mod
+  implicit none
+  integer, parameter :: m = 1000, n = 1000, o = 10
+  real(kind=8) :: A(m,n,o), sumA
+  A = 1.0d0
+  sumA = 0.0d0
+  call test(A, sumA)
+  if (sumA == real(m, 8)*n*o) then
+    print *, 'pass', sumA
+  else
+    print *, 'fail', sumA, ' expected', real(m, 8)*n*o
+  end if
+end program main
+! site:
+! title: nvfortran -acc: gang worker collapse(2) reduction with a nested vector reduction loses whole inner loops
+! control: ../vendor/checks/src/nvhpc/control/nvhpc-acc-gang-worker-collapse-nested-vector-reduction-lost-control.f90 gang
+! + collapse(2)
+! + instead of
+! + gang worker collapse(2)
+! end site

offload/_root/data/findings/fresh/nvhpc-teams-loop-module-allocatable-assign-fort2-crash.f90

@@ -0,0 +1,73 @@
+! # Finding (from the data/bench/fresh draft fresh-058): nvfortran's fort2 crashes on a
+!   whole-array assignment to a module allocatable in a target teams loop
+!
+! - source: data/bench/fresh/fresh-058.f90 (NVIDIA developer forum topic 294712, the reproducer of
+!   the 2024-06-05 reply, TPR 35799). The reporter's loop runs 10000 iterations that each assign
+!   all of A, a data race (every iteration writes the same elements); here the loop has one
+!   iteration, so the program is race-free, and the crash is the same
+! - compilers: NVHPC nvfortran 25.11 and 26.9, -mp=gpu -gpu=cc80 -O2 (separate and managed memory
+!   builds)
+! - expected: the program compiles and prints 7. A, an allocatable module array referenced in the
+!   target region, is not a scalar, so it is treated as map(tofrom) (OpenMP 5.2 §5.8.1 p.149
+!   l.4-5); Z, a scalar, is firstprivate; the single iteration assigns 7 to every element
+! - actual: "nvfortran-Fatal-.../maintainers/fort2 TERMINATED by signal 11", both releases, both
+!   memory-mode builds (the reporter's racy form too)
+! - control (same compiler): the same assignment compiles and prints 7 when A is a fixed-size
+!   module array (data/reports/fresh-drafts/d058-fixed.f90), a local allocatable (d058-local.f90),
+!   in a plain target region (d058-target.f90), in target teams distribute parallel do
+!   (d058-tdpd.f90), or as the element assignment A(II) = Z (d058-element.f90)
+! - other families: AFAR and CCE 19/20/21 compile this program and print 7 (MI300A, HSA_XNACK 1
+!   and 0; MI250X)
+! - legality: legal by reading: one iteration, so no two iterations touch A; the loop construct's
+!   restrictions (5.2 §11.7 p.257 l.29-34, p.258 l.1-4) and its implicit order(concurrent)
+!   (§10.3 p.234 l.14-24) allow the assignment
+! - evidence: results/fresh-drafts/wingtip/nv.jsonl, tuo-p4.jsonl, tioga/tioga-d.jsonl (review)
+MODULE GLOBALS
+   IMPLICIT NONE
+   REAL :: Z
+   REAL, ALLOCATABLE, DIMENSION(:)::A
+
+END MODULE GLOBALS
+
+MODULE RECON
+   USE GLOBALS
+
+   IMPLICIT NONE
+
+CONTAINS
+
+   SUBROUTINE CRASH_REPRO()
+
+      IMPLICIT NONE
+      INTEGER::II
+
+      ALLOCATE (A(10))
+      Z = 7
+
+      !$OMP target teams loop
+      DO II = 1, 1
+         A = Z;
+      END DO
+      !$OMP end target teams loop
+
+      PRINT *, A(1)
+
+   END SUBROUTINE CRASH_REPRO
+
+END MODULE RECON
+
+PROGRAM compilerCrashTest
+
+   USE RECON
+   IMPLICIT NONE
+
+   CALL CRASH_REPRO()
+
+END PROGRAM compilerCrashTest
+! site:
+! title: nvfortran -mp=gpu: fort2 crashes (signal 11) on a whole-array assignment to a module allocatable in target teams loop
+! control: ../vendor/checks/src/nvhpc/control/nvhpc-teams-loop-module-allocatable-assign-fort2-crash-control.f90 the element
+! + assignment
+! + A(II) = Z
+! + instead of the whole-array assignment A = Z
+! end site

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

@@ -0,0 +1,48 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1131 (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)
+! observed: device: fail crash: SIGABRT; host reference (afar/cce19) checksum=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-S-0034-Syntax error at or near :); 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 = 16, m = 8
+  integer, allocatable :: ia(:)
+  integer :: ib(n)
+  integer :: ic(n, m)
+  integer :: o1(n)
+  integer :: i, j
+  integer(8) :: cs
+  allocate(ia(n))
+  do i = 1, n
+    ia(i) = mod(i * 24 + 48, 30011) - 5205
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 24 + 3, 1009) - 72
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 9 * j) * 27 + 40, 211) - 68
+    end do
+  end do
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target enter data map(to: ia, ib, ic, o1)
+  !$omp target map(close, present, to: ic)
+  !$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
+! site:
+! title: AFAR offload runtime at HSA_XNACK=1: map(close, ...) breaks presence lookup and device access (abort, memory fault)
+! same_as: fuzz/s1-9443-afar
+! end site

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

@@ -0,0 +1,40 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1391 (fuzz-1).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "ACC - barrier/reset/protected last private not supported" (v_mt_translate.c, line
+!   5607, version <v>))
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "ACC - barrier/reset/protected last private not supported"
+!   (/workspace/crayftn/pdgcs/v_mt_translate.c, line 5607, version 668d73f
+! 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 = 32, m = 8
+  integer :: i, j, lp1, t1
+  integer(8) :: cs
+  lp1 = 0
+  ! fuzz: kernels
+  !$omp target
+    !$omp parallel
+      !$omp do lastprivate(lp1) private(t1)
+      do i = 1, n
+        do j = 1, m
+          t1 = 0
+          lp1 = 0
+        end do
+      end do
+    !$omp end parallel
+  !$omp end target
+  ! 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: internal compiler error "ACC - barrier/reset/protected last private not supported" for linear and lastprivate on a
+! + loop in a target region
+! same_as: catalog/cce-linear-lastprivate-ice
+! end site

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

@@ -0,0 +1,36 @@
+! Minimized by compliance.fuzz_min from fuzz seed 14 (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=24)
+! 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
+  implicit none
+  integer, parameter :: n = 24, m = 8
+  integer :: i, j, jj, lp1, acc1, t1
+  logical :: lsimd
+  integer(8) :: cs
+  lp1 = 0
+  lsimd = .false.
+  ! fuzz: kernels
+    !$omp target teams map(tofrom: lp1)
+      !$omp distribute parallel do simd lastprivate(lp1) private(t1, acc1, jj) num_threads(8)
+      do i = 1, n
+        t1 = 0
+        acc1 = 0
+        lp1 = i
+      end do
+      !$omp end distribute parallel do simd
+    !$omp end target teams
+  ! 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: craycc/ftn: lastprivate on distribute in a target region loses the final value, even with an explicit map
+! same_as: stress/cce-c-distribute-lastprivate-lost
+! end site

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

@@ -0,0 +1,88 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1505 (fuzz-1).
+! toolchain: cce20 (-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 (CCE 20.0.2; reruns,
+!   data/vendor/README.md: held, not reproducible); kept as a record.
+! observed: device: fail crash: SIGSEGV; host reference (cce20/afar) checksum=1148569567
+! 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 = mod(iand(max(7, x), y), 1009)
+  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 = 2
+  integer, allocatable :: ia(:)
+  integer, allocatable :: o1(:)
+  integer, allocatable :: o2(:, :)
+  integer, allocatable :: o3(:, :)
+  integer :: i, j, p1, r3b
+  logical :: lpar
+  integer(8) :: cs
+  allocate(ia(n))
+  allocate(o1(n))
+  allocate(o2(n, m))
+  allocate(o3(n, m))
+  do i = 1, n
+    ia(i) = mod(i * 24 + 3, 211) - 93
+  end do
+  o1 = 0
+  o2 = 0
+  o3 = 0
+  p1 = -5
+  r3b = 78
+  lpar = .false.
+  ! fuzz: kernels
+  !$omp target map(tofrom: r3b)
+    !$omp parallel if(parallel: lpar)
+      !$omp do reduction(min: r3b)
+      do i = n, 1, -1
+        do j = m, 1, -1
+          o3(i, j) = o2(i, j)
+          r3b = min(r3b, g1(o2(i, (mod(((j * 7) + 6), m) + 1)), p1))
+        end do
+      end do
+    !$omp end parallel
+  !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  do i = 1, n
+    cs = modulo(cs * 31_8 + int(o1(i), 8), 2147483629_8)
+  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
+  cs = modulo(cs * 31_8 + int(r3b, 8), 2147483629_8)
+  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
+! spec (requirement): a parallel construct whose if clause evaluates to false is executed by a team of one thread, and a
+!   reduction clause on a worksharing loop in that region gives each thread a private copy that is combined into the original list
+!   item at the end of the region, so the target region runs to completion with the host's result.
+! "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): the target region runs a worksharing do loop with reduction(min: r3b) inside parallel if(parallel: lpar)
+!   with lpar false (a team of one thread) and calls a declare target function; the host run completes, CCE 20 crashed on the
+!   device (the finding is kept as a record, not reproducible on the current install).
+! site:
+! title: ftn 20: a reduction(min) loop in parallel if(false) calling a declare target function crashed on the device (not
+! + reproducible now)
+! end site

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

@@ -0,0 +1,44 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1540 (fuzz-1).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (afar FIR verification: 'omp.target' op SPMD kernel must capture an 'omp.loop_nest' operation)
+! expected: compiles
+! observed: internal compiler error: ice: error: verification of lowering to FIR failed
+! 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-0034-Syntax error at or near :); 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 = 16, m = 4
+  integer :: i, j, lp1
+  integer(8) :: cs
+  lp1 = 0
+  ! fuzz: kernels
+  !$omp target parallel do lastprivate(conditional: lp1)
+  do i = 1, n
+  end do
+  !$omp end target parallel 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: amdflang: "'omp.target' op SPMD kernel must capture an 'omp.loop_nest' operation" for lastprivate(conditional:) on target
+! + parallel do
+! control: ../vendor/checks/src/fuzz/control/fuzz-1540-afar-control.f90 lastprivate(lp1) without the conditional modifier
+! end site
+! spec (requirement): the lastprivate clause accepts the conditional modifier on a worksharing loop (the original list item
+!   receives the value the last assigning iteration of sequential execution would leave), and on a combined construct with target
+!   the list item is mapped tofrom.
+! "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)
+! "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)
+! spec (this program): target parallel do lastprivate(conditional: lp1) with a loop body that assigns nothing is a legal
+!   combined construct that leaves lp1 unchanged; AFAR stops with an internal compiler error in FIR verification (SPMD kernel must
+!   capture an omp.loop_nest) instead of compiling it, while lastprivate(lp1) without the modifier compiles.

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

@@ -0,0 +1,63 @@
+! Minimized by compliance.fuzz_min from fuzz seed 158 (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)
+! observed: device: fail crash: SIGABRT; host reference (afar/cce19) checksum=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-S-0034-Syntax error at or near :); 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, y)
+    !$omp declare target
+    integer, intent(in) :: x, y
+    g1 = mod(((x * mod(3, 3)) - x), 97)
+  end function g1
+  integer function g2(x, y)
+    !$omp declare target
+    integer, intent(in) :: x, y
+    g2 = mod(ior(y, y), 1009)
+  end function g2
+end module fuzz_mod
+program fuzz_prog
+  use omp_lib, only: omp_get_default_device, omp_is_initial_device
+  use fuzz_mod, only: g1, g2
+  implicit none
+  integer, parameter :: n = 48, m = 2
+  integer :: ia(n)
+  integer, allocatable :: ib(:)
+  integer :: ic(n, m)
+  integer :: o1(n)
+  integer :: i, j
+  integer(8) :: cs
+  allocate(ib(n))
+  do i = 1, n
+    ia(i) = mod(i * 46 + 10, 211) - 53
+  end do
+  do i = 1, n
+    ib(i) = mod(i * 15 + 21, 30011) - 9080
+  end do
+  do j = 1, m
+    do i = 1, n
+      ic(i, j) = mod((i + 3 * j) * 30 + 28, 97) - 18
+    end do
+  end do
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target enter data map(to: ia, ib, ic, o1)
+  !$omp target map(close, present, tofrom: ib(1:n))
+  !$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
+! site:
+! title: AFAR offload runtime at HSA_XNACK=1: map(close, ...) breaks presence lookup and device access (abort, memory fault)
+! same_as: fuzz/s1-9443-afar
+! end site

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

@@ -0,0 +1,39 @@
+! Minimized by compliance.fuzz_min from fuzz seed 16 (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=535067391)
+! observed: device checksum=32891495 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_get_thread_num, omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 100, m = 5
+  integer :: o1(n)
+  integer :: i, j
+  integer(8) :: cs
+  o1 = 0
+  ! fuzz: kernels
+  !$omp target
+    !$omp parallel
+      if (omp_get_thread_num() == 0) then
+        do i = 1, n
+          o1(i) = 18
+        end do
+      end if
+    !$omp end parallel
+  !$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
+! 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/1644-cce21.f90

@@ -0,0 +1,31 @@
+! Minimized by compliance.fuzz_min from fuzz seed 1644 (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=20085)
+! observed: device checksum=2147483614 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_is_initial_device
+  implicit none
+  integer, parameter :: n = 200, m = 2
+  integer :: i, j, r1a
+  integer(8) :: cs
+  r1a = -15
+  ! fuzz: kernels
+  !$omp target map(tofrom: r1a) defaultmap(tofrom: allocatable)
+    do i = n, 1, -1
+      r1a = r1a + i
+    end do
+  !$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/165-cce19.f90

@@ -0,0 +1,52 @@
+! Minimized by compliance.fuzz_min from fuzz seed 165 (fuzz-1).
+! toolchain: cce19 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: INTERNAL COMPILER ERROR: "unhandled operator)
+! expected: compiles
+! observed: internal compiler error: ice: INTERNAL COMPILER ERROR:  "unhandled operator
+! 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: afar, cce20, cce21
+module fuzz_mod
+  implicit none
+contains
+  integer function g1(x, y)
+    !$omp declare target
+    integer, intent(in) :: x, y
+    g1 = mod(max((x + y), x), 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 = 16, m = 2
+  integer :: o1(n)
+  integer :: i, j, lp1, t1
+  logical :: lpar
+  integer(8) :: cs
+  o1 = 0
+  lp1 = 0
+  lpar = .true.
+  ! fuzz: kernels
+    !$omp target depend(out: o1)
+      !$omp parallel do lastprivate(conditional: lp1) private(t1)
+      do i = n, 1, -1
+        t1 = 0
+        if (mod(i, 2) == 1) lp1 = i
+      end do
+    !$omp end target
+  ! fuzz: checksum
+  cs = 0
+  cs = modulo(cs * 31_8 + int(lp1, 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: internal compiler error for lastprivate(conditional:) on a parallel loop in a target region
+! control: ../vendor/checks/src/fuzz/control/fuzz-165-cce19-control.f90 the same parallel do on the host (the target directive
+! + removed)
+! same_as: fuzz/958-cce20
+! end site