offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fuzz/controls/nvhpc-num-threads-removed-control.f90

@@ -0,0 +1,12 @@
+program p
+  implicit none
+  integer :: r, i
+  r = 3
+  !$omp target parallel do map(tofrom: r) reduction(*: r)
+  do i = 1, 8
+    r = r * 2
+  end do
+  !$omp end target parallel do
+  print '(a,i0)', 'r= ', r
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', r == 768)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-parallel-firstprivate-dropped-control.f90

@@ -0,0 +1,15 @@
+program p
+  implicit none
+  integer :: a(64), i, k
+  a = 0
+  k = 3
+  !$omp target parallel map(tofrom: a)
+    !$omp do
+    do i = 1, 64
+      a(i) = i + k
+    end do
+    !$omp end do nowait
+  !$omp end target parallel
+  print '(a,i0)', 'suma= ', sum(a)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 2080 + 64 * 3)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-parallel-single-nowait-control.f90

@@ -0,0 +1,13 @@
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer :: h
+  h = -1
+  !$omp target parallel map(tofrom: h)
+    !$omp single
+      h = merge(1, 0, omp_is_initial_device())
+    !$omp end single nowait
+  !$omp end target parallel
+  print '(a,i0)', 'h= ', h
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', merge(1, 0, h == 1), ' check=', merge('pass', 'fail', h == 0)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-parallel-split-control.f90

@@ -0,0 +1,15 @@
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer :: h
+  h = -1
+  !$omp target map(tofrom: h)
+  !$omp parallel
+    !$omp single
+      h = merge(1, 0, omp_is_initial_device())
+    !$omp end single
+  !$omp end parallel
+  !$omp end target
+  print '(a,i0)', 'h= ', h
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', merge(1, 0, h == 1), ' check=', merge('pass', 'fail', h == 0)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-simd-collapse-split-control.f90

@@ -0,0 +1,21 @@
+program p
+  implicit none
+  integer, parameter :: n = 16, m = 4
+  integer :: ia(n), i, j
+  real(4) :: o1(n, m)
+  do i = 1, n
+    ia(i) = mod(i * 22 + 1, 97) - 35
+  end do
+  o1 = 0.0
+  !$omp target map(from: o1) map(to: ia)
+    !$omp simd collapse(2)
+    do i = 1, n
+      do j = 1, m
+        o1(i, j) = real(ia(i) + j, 4)
+      end do
+    end do
+    !$omp end simd
+  !$omp end target
+  print '(a,f0.2)', 'o1= ', o1(1, 1)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', nint(o1(1, 1)) == ia(1) + 1)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-simd-end-directive-control.f90

@@ -0,0 +1,14 @@
+program p
+  implicit none
+  integer :: a(16), b(16), i, t
+  b = 1
+  a = 0
+  !$omp target simd map(tofrom: a) map(to: b) private(t)
+  do i = 1, 16
+    t = b(i)
+    a(i) = t + i
+  end do
+  !$omp end target simd
+  print '(a,i0)', 'suma= ', sum(a)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 152)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-simd-no-collapse-control.f90

@@ -0,0 +1,19 @@
+program p
+  implicit none
+  integer, parameter :: n = 16, m = 4
+  integer :: ia(n), i, j
+  real(4) :: o1(n, m)
+  do i = 1, n
+    ia(i) = mod(i * 22 + 1, 97) - 35
+  end do
+  o1 = 0.0
+  !$omp target simd map(from: o1) map(to: ia)
+  do i = 1, n
+    do j = 1, m
+      o1(i, j) = real(ia(i) + j, 4)
+    end do
+  end do
+  !$omp end target simd
+  print '(a,f0.2)', 'o1= ', o1(1, 1)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', nint(o1(1, 1)) == ia(1) + 1)
+end program p

offload/_root/data/findings/fuzz/controls/nvhpc-target-simd-split-no-end-directive-control.f90

@@ -0,0 +1,15 @@
+program p
+  implicit none
+  integer :: a(16), b(16), i, t
+  b = 1
+  a = 0
+  !$omp target map(tofrom: a) map(to: b)
+    !$omp simd private(t)
+    do i = 1, 16
+      t = b(i)
+      a(i) = t + i
+    end do
+  !$omp end target
+  print '(a,i0)', 'suma= ', sum(a)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 152)
+end program p

offload/_root/data/findings/fuzz/gcc-declare-reduction-module-not-found.f90

@@ -0,0 +1,66 @@
+! # Finding (GCC 16.2, fuzz sample): a declare reduction in a module is not found through use association
+!
+! - toolchains: gcc_g90 (GCC 16.2.0, AMD Instinct MI250X gfx90a, Tioga) and gcc_sm80 (GCC 16.2.0, NVIDIA A100 sm_80, wingtip);
+!   separate memory only; -O2
+! - build: gfortran -fopenmp -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90);
+!   -foffload=nvptx-none -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+! - failure: rejected: !$OMP DECLARE REDUCTION padd not found
+! - observed: `Error: !$OMP DECLARE REDUCTION padd not found at (1)` at the reduction clause, on both targets; the same happens on a
+!   host parallel do
+! - expected: compiles; prints `s%a= 5050 s%b= 100` and `RESULT ran_on_host=0 check=pass`
+! - rule: "If the reduction identifier is defined in a declare reduction directive, the declare reduction directive must be in the
+!   same subprogram, or accessible by host or use association" (5.2 §5.5.5 p.133 l.10-11): the directive is in module pair_m, which
+!   the program uses.
+! - same-compiler control (compiles; correct, gcc_sm80: mandatory pass 5 of 5; unset pass 5 of 5; gcc_g90: mandatory pass 5 of 5;
+!   unset pass 5 of 5 (results/parity/<machine>/<tc>/probes.jsonl)): the same declare reduction directive in the program's own
+!   specification part (controls/gcc-declare-reduction-module-control.f90).
+! - GCC's documentation: no row of libgomp.texi's tables names it (undocumented; user-defined reductions are OpenMP 4.0's).
+! - other families: no family runs this file: CCE 19/20/21/21.0.4 reject the reduction clause too, AFAR's front end accepts it and
+!   its link fails (flang_rt_verbose_abort undefined) and NVHPC 25.11/26.9 do not implement declare reduction (site matrix); on the
+!   fuzz programs every other family fails at another construct first. The claim rests on the rule and on GCC's own control. The
+!   site's finding matrix runs this file on every compiler.
+! - fuzz programs (380 cells (190 gcc_g90, 190 gcc_sm80); gate: confirmed 380; confirmer: needs_human (R12b-compile-undecided) 380):
+!   n1:121, n1:22, n1:234, n1:31, n1:312, n1:362, n1:371, n1:41, n1:428, n1:430, n1:511, n1:748, n1:804, n1:809, n1:813, n1:832,
+!   n1:841, n1:939, n1:944, n1:987, s1:1198, s1:1204, s1:1205, s1:1222, s1:1240, s1:1261, s1:1300, s1:1344, s1:1362, s1:1375,
+!   s1:1455, s1:1556, s1:1610, s1:1631, s1:1723, s1:1727, s1:1802, s1:1849, s1:1899, s1:1957, and 150 more (the index entry lists
+!   them)
+! - legality: two witnesses that are neither GCC nor a compiler this finding is about, offload.engine.rules and AFAR flang's
+!   front end,
+!   accept this file and its control (offload.engine.prerun.check; results/parity/tioga/results/parity/legality.jsonl) and the fuzz
+!   programs (the campaign's legality gate; its base-language check, gfortran -std=f2008 without OpenMP, is a syntax check of the
+!   base language only and no witness). GCC is a compiler under test only and never a legality witness.
+module pair_m
+  implicit none
+  type :: pair_t
+    integer :: a, b
+  end type pair_t
+  !$omp declare reduction(padd: pair_t: omp_out = &
+  !$omp& pair_t(omp_out%a + omp_in%a, omp_out%b + omp_in%b)) &
+  !$omp& initializer(omp_priv = pair_t(0, 0))
+end module pair_m
+
+program udr_use_association
+  use omp_lib, only: omp_is_initial_device
+  use pair_m
+  implicit none
+  type(pair_t) :: s
+  integer :: i, host_flag
+  s = pair_t(0, 0)
+  host_flag = 1
+  !$omp target teams distribute parallel do reduction(padd: s) map(tofrom: s, host_flag)
+  do i = 1, 100
+    if (i == 1) host_flag = merge(1, 0, omp_is_initial_device())
+    s%a = s%a + i
+    s%b = s%b + 1
+  end do
+  print '(a,i0,a,i0)', 's%a= ', s%a, ' s%b= ', s%b
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', s%a == 5050 .and. s%b == 100)
+end program udr_use_association
+! site:
+! title: A declare reduction in a module is not found through use association
+! summary: A user-defined reduction declared in a module's specification part is accessible through use association. GCC
+! + 16.2's Fortran front end rejects its use in a target teams distribute parallel do reduction clause ("!$OMP DECLARE
+! + REDUCTION padd not found"), for both offload targets and on the host. With the declare reduction directive in the
+! + program's own specification part the program compiles and runs correctly.
+! control: fuzz/controls/gcc-declare-reduction-module-control.f90 the declare reduction directive in the program itself
+! end site

offload/_root/data/findings/fuzz/gcc-strided-target-update-rejected.f90

@@ -0,0 +1,58 @@
+! # Finding (GCC 16.2, fuzz sample): a Fortran array section with a stride in a target update motion clause is rejected
+!
+! - toolchains: gcc_g90 (GCC 16.2.0, AMD Instinct MI250X gfx90a, Tioga) and gcc_sm80 (GCC 16.2.0, NVIDIA A100 sm_80, wingtip);
+!   separate memory only; -O2
+! - build: gfortran -fopenmp -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90);
+!   -foffload=nvptx-none -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+! - failure: rejected: Array is not contiguous
+! - observed: `Error: Array is not contiguous at (1)` and `Error: Stride should not be specified for array section in FROM clause at
+!   (1)` at the target update directive, on both targets
+! - expected: compiles; prints `bad= 0` and `RESULT ran_on_host=0 check=pass` (only the odd elements come back)
+! - rule: "The target update construct ... was modified to allow array sections that specify discontiguous storage" (5.2 §B.4 p.634
+!   l.3-4, the changes from 4.5 to 5.0); the contiguous-storage restriction is the map clause's (5.2 §5.8.3 p.155 l.10), not the
+!   motion clauses'.
+! - GCC's documentation: libgomp.texi, OpenMP 5.0 table: "Discontiguous array section with target update construct: N" (not
+!   supported, documented). The C form is harvest/gcc-c-strided-section-rejected.c.
+! - other families: AFAR, CCE and NVHPC fail this file another way (site matrix; AFAR's own strided-update finding is
+!   harvest/afar-flang-strided-target-update.f90). The site's finding matrix runs this file on every compiler.
+! - fuzz programs (116 cells (58 gcc_g90, 58 gcc_sm80); gate: confirmed 116; confirmer: needs_human (R12b-compile-undecided) 106,
+!   compiler_bug (R11-compile-rejection) 10): s1:1040, s1:1692, s1:1792, s1:2014, s1:2084, s1:2160, s1:2267, s1:2617, s1:2744,
+!   s1:2949, s1:2970, s1:3049, s1:3197, s1:3219, s1:3392, s1:3457, s1:3503, s1:3685, s1:4207, s1:4477, s1:4501, s1:4655, s1:4680,
+!   s1:4788, s1:5088, s1:5371, s1:5383, s1:547, s1:5522, s1:562, s1:6125, s1:6197, s1:6430, s1:6554, s1:6670, s1:6685, s1:6831,
+!   s1:6915, s1:7055, s1:7099, and 18 more (the index entry lists them)
+! - legality: two witnesses that are neither GCC nor a compiler this finding is about, offload.engine.rules and AFAR flang's front
+!   end, accept this file (offload.engine.prerun.check; results/parity/tioga/results/parity/legality.jsonl) and the fuzz programs
+!   (the campaign's legality gate; its base-language check, gfortran -std=f2008 without OpenMP, is a syntax check of the base
+!   language only and no witness). GCC is a compiler under test only and never a legality witness.
+program target_update_strided
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 16
+  integer :: a(n), i, bad, host_flag
+  a = -1
+  !$omp target enter data map(to: a)
+  host_flag = 1
+  !$omp target map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    do i = 1, n
+      a(i) = i
+    end do
+  !$omp end target
+  ! every second element: a(1), a(3), ..., a(15)
+  !$omp target update from(a(1:n:2))
+  !$omp target exit data map(delete: a)
+  bad = 0
+  do i = 1, n
+    if (mod(i, 2) == 1 .and. a(i) /= i) bad = bad + 1
+    if (mod(i, 2) == 0 .and. a(i) /= -1) bad = bad + 1
+  end do
+  print '(a,i0)', 'bad= ', bad
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', bad == 0)
+end program target_update_strided
+! site:
+! title: A Fortran array section with a stride in a target update motion clause is rejected
+! summary: OpenMP 5.0 allows array sections that specify discontiguous storage in target update. GCC 16.2 rejects
+! + from(a(1:n:2)) ("Array is not contiguous") for both offload targets; its documentation lists discontiguous array sections
+! + in target update as not supported.
+! same_as: harvest/gcc-c-strided-section-rejected
+! end site

offload/_root/data/findings/fuzz/gcc-target-simd-map-nontemporal-rejected.f90

@@ -0,0 +1,54 @@
+! # Finding (GCC 16.2, fuzz sample): the same array in map and nontemporal of target simd is rejected (Fortran)
+!
+! - toolchains: gcc_g90 (GCC 16.2.0, AMD Instinct MI250X gfx90a, Tioga) and gcc_sm80 (GCC 16.2.0, NVIDIA A100 sm_80, wingtip);
+!   separate memory only; -O2
+! - build: gfortran -fopenmp -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90);
+!   -foffload=nvptx-none -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+! - failure: rejected: present on multiple clauses
+! - observed: `Error: Symbol 'o' present on multiple clauses at (1)` at the nontemporal clause, on both targets; the C form
+!   (results/parity/probes-r2/nontemporal_c.c) compiles and runs correctly on both (mandatory pass 5 of 5; unset pass 5 of 5)
+! - expected: compiles; prints `bad= 0` and `RESULT ran_on_host=0 check=pass`
+! - rule: on a combined construct each clause applies to the leaf constructs that allow it (5.2 §17.2 p.341): map to target,
+!   nontemporal to simd; nontemporal is no data-sharing attribute clause, so the map restriction "A list item cannot appear in both
+!   a map clause and a data-sharing attribute clause on the same construct" does not apply.
+! - same-compiler control (compiles; correct, gcc_sm80: mandatory pass 5 of 5; unset pass 5 of 5; gcc_g90: mandatory pass 5 of 5;
+!   unset pass 5 of 5 (results/parity/<machine>/<tc>/probes.jsonl)): the same construct without nontemporal
+!   (controls/gcc-target-simd-map-nontemporal-control.f90).
+! - GCC's documentation: no row of libgomp.texi's tables names it (undocumented; nontemporal is OpenMP 5.0's).
+! - other families: AFAR and CCE 19/20/21/21.0.4 run this file correctly in both memory modes; NVHPC 25.11/26.9 fail it another way
+!   (site matrix). The site's finding matrix runs this file on every compiler.
+! - fuzz programs (44 cells (22 gcc_g90, 22 gcc_sm80); gate: confirmed 44; confirmer: needs_human (R12b-compile-undecided) 35,
+!   compiler_bug (R11-compile-rejection) 9): b0:227, b0:294, c1:1350, c1:1688, c1:1721, c1:18, c1:209, c1:227, c1:427, c1:469,
+!   s1:1336, s1:1608, s1:2321, s1:327, s1:3745, s1:4530, s1:9979, x0-alloc:191, x0-declare:70, x0-multitu:111, x0-multitu:227,
+!   x0-types:220
+! - legality: two witnesses that are neither GCC nor a compiler this finding is about, offload.engine.rules and AFAR flang's
+!   front end,
+!   accept this file and its control (offload.engine.prerun.check; results/parity/tioga/results/parity/legality.jsonl) and the fuzz
+!   programs (the campaign's legality gate; its base-language check, gfortran -std=f2008 without OpenMP, is a syntax check of the
+!   base language only and no witness). GCC is a compiler under test only and never a legality witness.
+program target_simd_map_nontemporal
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: o(n), i, bad, host_flag
+  o = 0
+  host_flag = 1
+  !$omp target map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  ! map applies to the target leaf, nontemporal to the simd leaf
+  !$omp target simd map(tofrom: o) nontemporal(o)
+  do i = 1, n
+    o(i) = 2 * i
+  end do
+  bad = count(o /= [(2 * i, i = 1, n)])
+  print '(a,i0)', 'bad= ', bad
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', bad == 0)
+end program target_simd_map_nontemporal
+! site:
+! title: The same array in map and nontemporal clauses of a Fortran target simd construct is rejected
+! summary: On target simd, map applies to the target leaf and nontemporal to the simd leaf. GCC 16.2's Fortran front end
+! + rejects an array named in both ("present on multiple clauses") for both offload targets; the C form compiles and runs. Without
+! + nontemporal the program compiles and runs correctly.
+! control: fuzz/controls/gcc-target-simd-map-nontemporal-control.f90 the same construct without nontemporal
+! end site

offload/_root/data/findings/fuzz/nvhpc-allocatable-component-implicit-map-illegal-address.f90

@@ -0,0 +1,84 @@
+! # Finding (parity-fuzz-s1): NVHPC: reading an allocatable component of a derived-type variable that the target construct maps
+! # whole (implicitly or with map(to:)) ends in CUDA_ERROR_ILLEGAL_ADDRESS in separate memory; with the component itself in a
+! # map clause the result is right
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11), nvhpc269 (NVHPC 26.9); modes: copy; -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -gpu=mem:separate -O2
+! - failure: run_error
+! - observed: `Accelerator Fatal Error: call to cuMemcpyDtoHAsync returned error 700 (CUDA_ERROR_ILLEGAL_ADDRESS): Illegal
+!   address during kernel execution`, exit status 1, and the same without OMP_TARGET_OFFLOAD=mandatory (the rows' stderr; the
+!   harness's reason reads `exit_status: 1; without mandatory: exit_status: 1`); identical signature on 2 of 2 failing cells
+!   (separate memory; in managed memory the program is correct)
+! - expected: compiles and prints `sum= 1360` with `check=pass`
+! - rule: "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) maps dr whole, and "If a component of a derived type list item is a map clause list item that
+!   results from the predefined default mapper for that derived type" (5.2 §5.8.3 p.151 l.29-30) names the components the
+!   default mapper maps; the only latitude for an allocatable component applies when it "is present in the device data
+!   environment when the construct is encountered" (5.2 §5.8.3 p.151 l.34-37), which dr%q is not: its storage is mapped with dr
+!   and the kernel may read it
+! - vendor: "The map clause is supported as described in 2.19.7" on the target construct (item 2.12.5) and "Data Mapping
+!   Attribute Rules, Clauses, and Directives" (item 2.19.7) (NVIDIA HPC Compilers User's Guide 26.9, Using OpenMP;
+!   data/index/claims/nvidia-hpc-26.9-user-guide-openmp.txt); the guide names no limit on allocatable components
+! - same-compiler control: controls/nvhpc-allocatable-component-mapped-control.f90 (one change from this file; correct on nvhpc
+!   (NVHPC 25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.ac.jsonl, results/parity/nvs1/wt.ac.jsonl);
+!   controls/nvhpc-allocatable-component-unreferenced-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11),
+!   nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.ac.jsonl, results/parity/nvs1/wt.ac.jsonl)
+! - other families: afar (AFAR 24.3.0), cce19 (CCE 19.0.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4) run the
+!   file correctly (rows results/parity/nvs1/tuo.ac.jsonl)
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.ac.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.ac.jsonl: dr in map(to: dr)
+!   (nvhpc-allocatable-component-map-to-variant.f90), the loop as teams distribute
+!   (nvhpc-allocatable-component-teams-distribute-variant.f90), the kernel in an internal procedure with dr an intent(inout)
+!   dummy (nvhpc-allocatable-component-dummy-variant.f90, the seeds' shape) and the output a declare target module array read
+!   back with target update (nvhpc-allocatable-component-declare-target-output-variant.f90, seed 6329's shape) all fail the same
+!   way in separate memory and are correct in managed memory. Every program below reads dr%q in its kernel with dr mapped whole.
+!   Seed 1994 carries the c1 depend finding's message (cuEventQuery error 700) but not its trigger: its depend list names only
+!   variables present through target enter data (the shape that finding leaves uncounted), and once its depend clauses are
+!   removed it fails this way, at cuMemcpyDtoHAsync (exploration); it is counted nowhere. Seed 6719, which maps dr%q itself and
+!   crashes AFAR and CCE 21 too, is not counted either
+! - gate and confirmer: 2 of 2 cells reproduce in all four environments (a-d; (c) on another node or GPU than (a); rows
+!   results/parity/nvs1/gate_abd.ac.jsonl, results/parity/nvs1/gate_c.ac.jsonl, results/parity/nvs1/wt.ac.jsonl); campaign gate of
+!   the programs below: 14 cells, 14 confirmed in the four environments (a-d; (c) on another node or GPU; rows
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2465893.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2476695.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3354124.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3482833.jsonl)
+! - programs (7): par-s1-nvhpc-nvhpc269:2670, par-s1-nvhpc-nvhpc269:4516, par-s1-nvhpc-nvhpc269:4913, par-s1-nvhpc-nvhpc269:5351,
+!   par-s1-nvhpc-nvhpc269:5538, par-s1-nvhpc-nvhpc269:6329, par-s1-nvhpc-nvhpc269:2004
+! - legality: the rules (offload.engine.rules) and AFAR's flang front end accept this file, its controls and the variants above
+!   (offload.engine.prerun.check on a Tuolumne compute node; results/parity/nvs1/prerun.ac.txt); AFAR 24.3.0 and CCE 19/20/21/21.0.4
+!   compile and run all of them correctly with HSA_XNACK 0 and 1 (results/parity/nvs1/tuo.ac.jsonl). NVHPC is the compiler under
+!   test and is not counted as a witness
+program p
+  implicit none
+  type :: rec_t
+    integer :: a(16)
+    integer, allocatable :: q(:)
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: o(16), i
+  allocate(dr%q(16))
+  do i = 1, 16
+    dr%a(i) = i
+    dr%q(i) = 10 * i
+  end do
+  o = 0
+  !$omp target map(from: o)
+  do i = 1, 16
+    o(i) = dr%q(i)
+  end do
+  !$omp end target
+  print '(a,i0)', 'sum= ', sum(o)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(o) == 1360)
+end program p
+
+! site:
+! title: allocatable component of a mapped structure: illegal address
+! summary: nvfortran -mp=gpu appears to behave incorrectly when a target region reads an allocatable component of a derived-type
+! + variable that is mapped whole, implicitly or with map(to:), in separate memory: the kernel ends in
+! + CUDA_ERROR_ILLEGAL_ADDRESS. With the component itself in a map clause, when only a non-allocatable component is read, or in
+! + managed memory, the result is right.
+! control: fuzz/controls/nvhpc-allocatable-component-mapped-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-allocatable-component-unreferenced-control.f90 one change from the finding; correct on nvhpc,
+! + nvhpc269
+! end site

offload/_root/data/findings/fuzz/nvhpc-assumed-length-character-dummy-map-ice.f90

@@ -0,0 +1,69 @@
+! # Finding (parity-fuzz-s1): NVHPC 25.11: an assumed-length character dummy argument in a map clause of a target region stops
+! # the compile with an internal compiler error ("size_of: attempt to size assumed size character"); with an explicit length it
+! # compiles and runs correctly, and 26.9 compiles both
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11); modes: copy, managed; -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -gpu=mem:separate -O2
+! - failure: rejected
+! - observed: `NVFORTRAN-S-0000-Internal compiler error. size_of: attempt to size assumed size character       0
+!   (<tmpdir>/nvhpc-assumed-length-character-dummy-map-`; identical signature on 2 of 2 failing cells
+! - expected: compiles and prints `r= 78` with `check=pass`
+! - rule: "The map clause specifies how an original list item is mapped from the current task's data environment to a
+!   corresponding list item in the device data environment" (5.2 §5.8.3 p.151 l.8-9): an assumed-length character dummy is a
+!   character scalar variable whose length is that of the actual argument, a list item like any other scalar
+! - vendor: "The map clause is supported as described in 2.19.7" on the target construct (NVIDIA HPC Compilers User's Guide
+!   26.9, Using OpenMP, item 2.12.5; data/index/claims/nvidia-hpc-26.9-user-guide-openmp.txt)
+! - same-compiler control: controls/nvhpc-explicit-length-character-dummy-control.f90 (one change from this file; correct on nvhpc
+!   (NVHPC 25.11); rows results/parity/nvs1/tuo.ch.jsonl, results/parity/nvs1/wt.ch.jsonl)
+! - other families: afar (AFAR 24.3.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4) run the file correctly
+!   (rows results/parity/nvs1/tuo.ch.jsonl); cce19 (CCE 19.0.0) fail it another way, e.g. `ftn-7032 ftn: ERROR KP1, File =
+!   ../../nvhpc-assumed-length-character-dummy-map-ice.f90, Line = 15`
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.ch.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.ch.jsonl: the dummy mapped implicitly
+!   (nvhpc-assumed-length-character-dummy-implicit-variant.f90) fails the same way on 25.11 and is correct on 26.9; NVHPC 26.9
+!   compiles and runs this file correctly in both memory modes (results/parity/nvs1/wt.ch.jsonl and the gate rows), the same
+!   family, not a witness. The s1 program 8930 fails on 26.9 at run time ("Present table errors" at the same dummy): with the
+!   dummy given an explicit length the whole seed runs with the expected checksum on both releases (exploration), but no small
+!   program reproduced the 26.9 failure
+! - gate and confirmer: 2 of 2 cells reproduce in all four environments (a-d; (c) on another node or GPU than (a); rows
+!   results/parity/nvs1/gate_abd.ch.jsonl, results/parity/nvs1/gate_abd.ch.m2.jsonl, results/parity/nvs1/gate_c.ch.jsonl,
+!   results/parity/nvs1/gate_c.ch.m2.jsonl, results/parity/nvs1/wt.ch.jsonl); campaign gate of the programs below: 1 cells, 1
+!   confirmed in the four environments (a-d; (c) on another node or GPU; rows
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2476695.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3482833.jsonl)
+! - programs (1): par-s1-nvhpc-nvhpc269:8930; seed 8781 on 25.11 carries the same ICE message in its cell's stderr behind a
+!   first diagnostic of SIMDLEN not implemented (a character(len=*) dummy in map(always, tofrom:)), so it is not counted; on
+!   26.9 that seed runs with a wrong checksum
+! - legality: the rules (offload.engine.rules) and AFAR's flang front end accept this file, its control and the variant above
+!   (offload.engine.prerun.check on a Tuolumne compute node; results/parity/nvs1/prerun.ch.txt); AFAR 24.3.0 and CCE 20/21/21.0.4
+!   compile and run all of them correctly with HSA_XNACK 0 and 1 (results/parity/nvs1/tuo.ch.jsonl); CCE 19 rejects character
+!   data in target regions ("Unsupported OpenMP construct Fortran character"), its own documented limit
+!   (afar-cce19-character-defaultmap.f90). NVHPC 26.9 compiles and runs this file correctly but is not counted as a witness:
+!   NVHPC is the compiler under test
+program p
+  implicit none
+  integer :: r
+  character(len=8) :: xs
+  xs = 'NnLXCqNL'
+  r = 0
+  call kp1(xs, r)
+  print '(a,i0)', 'r= ', r
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', r == ichar('N'))
+contains
+  subroutine kp1(xs, r)
+    character(len=*), intent(in) :: xs
+    integer, intent(inout) :: r
+    !$omp target map(to: xs) map(tofrom: r)
+    r = ichar(xs(1:1))
+    !$omp end target
+  end subroutine kp1
+end program p
+
+! site:
+! title: assumed-length character dummy in a map clause: ICE
+! summary: nvfortran 25.11 -mp=gpu appears to behave incorrectly on an assumed-length character dummy argument
+! + (character(len=*)) named in a map clause of a target region, or mapped implicitly: the compile stops with the internal
+! + compiler error "size_of: attempt to size assumed size character". With an explicit length it compiles and runs correctly;
+! + 26.9 compiles and runs both.
+! control: fuzz/controls/nvhpc-explicit-length-character-dummy-control.f90 one change from the finding; correct on nvhpc
+! end site

offload/_root/data/findings/fuzz/nvhpc-default-none-reduction-lastprivate-fort1-crash.f90

@@ -0,0 +1,70 @@
+! # Finding (parity-fuzz-s1): NVHPC: a teams distribute parallel do with reduction, lastprivate and default(none) crashes the
+! # front end (fort1 killed by signal 11); without default(none), or with default(shared), it compiles and runs correctly
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11), nvhpc269 (NVHPC 26.9); modes: copy, managed; -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -gpu=mem:separate -O2
+! - failure: ice
+! - observed: `nvfortran-Fatal-$NVHPC_25_11/compilers/bin/tools/fort1 TERMINATED by signal 11`; identical signature on 4 of 4
+!   failing cells
+! - expected: compiles and prints `suma= 36 r= 36` with `check=pass`
+! - rule: "If data-sharing-attribute is none, each variable that is referenced in the construct and does not have a
+!   predetermined data-sharing attribute must have its data-sharing attribute explicitly determined by being listed in a
+!   data-sharing attribute clause." (5.2 §5.4.1 p.109 l.15-17): r and lp are listed in the reduction and lastprivate clauses, a
+!   in shared, and the loop variable i is predetermined private, so the program meets the restriction
+! - vendor: "The num_threads, default, private, firstprivate, and shared clauses" are supported on the parallel construct and
+!   "The reduction clause is supported" (items 2.6 and 2.19.5); "The lastprivate clause is supported" on the worksharing loop
+!   (item 2.9.2) (NVIDIA HPC Compilers User's Guide 26.9, Using OpenMP; data/index/claims/nvidia-hpc-26.9-user-guide-openmp.txt)
+! - same-compiler control: controls/nvhpc-default-none-removed-control.f90 (one change from this file; correct on nvhpc (NVHPC
+!   25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.st.jsonl, results/parity/nvs1/wt.st.jsonl);
+!   controls/nvhpc-default-shared-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11), nvhpc269 (NVHPC 26.9);
+!   rows results/parity/nvs1/tuo.st.jsonl, results/parity/nvs1/wt.st.jsonl)
+! - other families: cce19 (CCE 19.0.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4) run the file correctly
+!   (rows results/parity/nvs1/tuo.st.jsonl); afar (AFAR 24.3.0) fail it another way: `not yet implemented: lastprivate clause in
+!   constructs other than simd/worksharing-loop/taskloop` in its lowering (AFAR's own limit; the same on both controls and the
+!   variant)
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.st.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.st.jsonl: default(none) kept and the reduction removed
+!   (nvhpc-default-none-reduction-removed-variant.f90) compiles and is correct, so the crash needs the three clauses together.
+!   The programs check the array and the reduction only: neither release copies the lastprivate value of a distribute loop back
+!   (lp stays 0), the documented limit "The lastprivate clause is not supported" on distribute (item 2.9.4). The seed's simd,
+!   firstprivate and num_threads clauses, its declare target module structure and its allocatable component are irrelevant
+!   (exploration)
+! - gate and confirmer: 4 of 4 cells reproduce in all four environments (a-d; (c) on another node or GPU than (a); rows
+!   results/parity/nvs1/gate_abd.st.jsonl, results/parity/nvs1/gate_abd.st.m2.jsonl, results/parity/nvs1/gate_c.st.jsonl,
+!   results/parity/nvs1/gate_c.st.m2.jsonl, results/parity/nvs1/wt.st.jsonl); campaign gate of the programs below: 2 cells, 2
+!   confirmed in the four environments (a-d; (c) on another node or GPU; rows
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2465893.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3354124.jsonl)
+! - programs (1): par-s1-nvhpc-nvhpc269:8009
+! - legality: the rules (offload.engine.rules) and AFAR's flang front end accept this file, its controls and the variant above
+!   (offload.engine.prerun.check on a Tuolumne compute node; results/parity/nvs1/prerun.st.txt); CCE 19/20/21/21.0.4 compile and run
+!   all of them correctly with HSA_XNACK 0 and 1 (results/parity/nvs1/tuo.st.jsonl); AFAR 24.3.0 stops on every one of them in
+!   its lowering (`not yet implemented: lastprivate clause in constructs other than simd/worksharing-loop/taskloop`,
+!   results/parity/nvs1/tuo.st.jsonl), AFAR's own limit. NVHPC is the compiler under test and is not counted as a witness
+program p
+  implicit none
+  integer :: a(8), i, lp, r
+  a = 0
+  lp = 0
+  r = 0
+  !$omp target map(tofrom: a, r) map(from: lp)
+    !$omp teams distribute parallel do reduction(+: r) lastprivate(lp) default(none) shared(a)
+    do i = 1, 8
+      a(i) = i
+      r = r + i
+      lp = i
+    end do
+    !$omp end teams distribute parallel do
+  !$omp end target
+  print '(a,i0,a,i0)', 'suma= ', sum(a), ' r= ', r
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 36 .and. r == 36)
+end program p
+
+! site:
+! title: default(none) with reduction and lastprivate: compiler crash
+! summary: nvfortran -mp=gpu appears to behave incorrectly on a teams distribute parallel do construct that has a reduction, a
+! + lastprivate and a default(none) clause: the front end is killed by signal 11. Without default(none), or with
+! + default(shared), it compiles and runs correctly.
+! control: fuzz/controls/nvhpc-default-none-removed-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-default-shared-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! end site

offload/_root/data/findings/fuzz/nvhpc-defaultmap-firstprivate-lastprivate-ice.f90

@@ -0,0 +1,71 @@
+! # Finding (parity-fuzz-s1): NVHPC: defaultmap(firstprivate: scalar) on a target construct whose parallel do has a lastprivate
+! # clause stops the compile with an internal compiler error ("offset should not be overridden"); without the clause, or with
+! # defaultmap(tofrom: scalar), it compiles and runs correctly
+!
+! - toolchains and modes that fail: nvhpc (NVHPC 25.11), nvhpc269 (NVHPC 26.9); modes: copy, managed; -O2
+! - build: nvfortran -mp=gpu -gpu=cc80 -gpu=mem:separate -O2
+! - failure: rejected
+! - observed: `NVFORTRAN-F-0000-Internal compiler error. offset should not be overridden     321
+!   (<tmpdir>/nvhpc-defaultmap-firstprivate-lastprivate-ice.f90: 12)`; identical signature on 4 of 4 failing cells
+! - expected: compiles and prints `suma= 36 lp= 8` with `check=pass`
+! - rule: "If implicit-behavior is firstprivate, the attribute is a data-sharing attribute of firstprivate." (5.2 §5.8.7 p.162
+!   l.5-6): the clause sets the implicit attribute of the scalars the construct does not list; here lp is mapped explicitly and
+!   the loop variable is predetermined private, so the clause changes no variable's attribute
+! - vendor: "The defaultmap clause is supported using OpenMP 5.0 semantics" (NVIDIA HPC Compilers User's Guide 26.9, Using
+!   OpenMP, item 2.12.5; data/index/claims/nvidia-hpc-26.9-user-guide-openmp.txt); firstprivate is a 5.0 implicit-behavior
+! - same-compiler control: controls/nvhpc-defaultmap-firstprivate-removed-control.f90 (one change from this file; correct on nvhpc
+!   (NVHPC 25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.dm.jsonl, results/parity/nvs1/wt.dm.jsonl);
+!   controls/nvhpc-defaultmap-tofrom-lastprivate-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11), nvhpc269
+!   (NVHPC 26.9); rows results/parity/nvs1/tuo.dm.jsonl, results/parity/nvs1/wt.dm.jsonl)
+! - other families: cce19 (CCE 19.0.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4) run the file correctly (rows
+!   results/parity/nvs1/tuo.dm.jsonl); afar (AFAR 24.3.0) fail it another way, e.g. `LLVM ERROR: aborting`
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.dm.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.dm.jsonl: the lastprivate variable left unmapped, so that the
+!   defaultmap applies to it (nvhpc-defaultmap-firstprivate-lastprivate-unmapped-variant.f90), fails the same way; the combined
+!   target teams distribute parallel do with the same clauses (nvhpc-defaultmap-firstprivate-lastprivate-combined-variant.f90)
+!   compiles but does not copy the lastprivate value back (lp = 0 on 26.9, an uninitialized value on 25.11), the documented
+!   limit "The lastprivate clause is not supported" on distribute (item 2.9.4). The seed's kernel nests the parallel do
+!   lastprivate in teams distribute lastprivate and adds schedule(dynamic, 7); without the defaultmap the seed's shape is
+!   rejected for the dynamic schedule on 25.11 ("Only static schedule kind is supported for GPU") and compiles on 26.9
+!   (exploration)
+! - gate and confirmer: 4 of 4 cells reproduce in all four environments (a-d; (c) on another node or GPU than (a); rows
+!   results/parity/nvs1/gate_abd.dm.jsonl, results/parity/nvs1/gate_abd.dm.m2.jsonl, results/parity/nvs1/gate_c.dm.jsonl,
+!   results/parity/nvs1/gate_c.dm.m2.jsonl, results/parity/nvs1/wt.dm.jsonl); campaign gate of the programs below: 2 cells, 2
+!   confirmed in the four environments (a-d; (c) on another node or GPU; rows
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2465893.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.2476695.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3354124.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3482833.jsonl)
+! - programs (1): par-s1-nvhpc-nvhpc269:9895; the same ICE message is in the stderr of seed 1555's cells on both releases
+!   (defaultmap(firstprivate: scalar) on a target construct with do lastprivate inside), whose first diagnostic is the
+!   unrecognized declare directive of its module, so it is not counted
+! - legality: the rules (offload.engine.rules) and AFAR's flang front end accept this file, its controls and the variants above
+!   (offload.engine.prerun.check on a Tuolumne compute node; results/parity/nvs1/prerun.dm.txt); CCE 19/20/21/21.0.4 compile and run
+!   this file, its controls and the unmapped variant correctly with HSA_XNACK 0 and 1 (results/parity/nvs1/tuo.dm.jsonl); AFAR
+!   24.3.0 runs both controls correctly and stops on every file with defaultmap(firstprivate: scalar) in its lowering ("not yet
+!   implemented", results/parity/nvs1/tuo.dm.jsonl), AFAR's own limit. NVHPC is the compiler under test and is not counted as a
+!   witness
+program p
+  implicit none
+  integer :: a(8), j, lp
+  a = 0
+  lp = 0
+  !$omp target map(tofrom: a, lp) defaultmap(firstprivate: scalar)
+    !$omp parallel do lastprivate(lp)
+    do j = 1, 8
+      a(j) = j
+      lp = j
+    end do
+  !$omp end target
+  print '(a,i0,a,i0)', 'suma= ', sum(a), ' lp= ', lp
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 36 .and. lp == 8)
+end program p
+
+! site:
+! title: defaultmap(firstprivate: scalar) with lastprivate: ICE
+! summary: nvfortran -mp=gpu appears to behave incorrectly on a target construct with defaultmap(firstprivate: scalar) that
+! + contains a parallel do with a lastprivate clause: the compile stops with the internal compiler error "offset should not be
+! + overridden". Without the defaultmap clause, or with defaultmap(tofrom: scalar), it compiles and runs correctly.
+! control: fuzz/controls/nvhpc-defaultmap-firstprivate-removed-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-defaultmap-tofrom-lastprivate-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! end site