offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/fuzz/nvhpc-target-parallel-single-hang.f90

@@ -0,0 +1,68 @@
+! # Finding (parity-fuzz-c1): NVHPC: a barrier inside a combined target parallel construct never completes (the end of a single, of
+! # a worksharing loop, an explicit barrier); the same region as target containing parallel ends
+!
+! - 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: timeout
+! - observed: `RUN_TIMEOUT`: the program does not end and is killed at the harness limit (60 s) in every run
+!   (OMP_TARGET_OFFLOAD=mandatory); identical signature on 4 of 4 failing cells
+! - expected: compiles and prints `h= 0` with `check=pass`
+! - rule: "An implicit barrier occurs at the end of a single region if the nowait clause is not specified." (5.2 §11.1 p.241 l.5-6),
+!   and "The semantics of the combined constructs are identical to that of explicitly specifying the first construct containing one
+!   instance of the second construct and no other statements." (5.2 §17.4 p.343 l.7-8): the program is a target region holding one
+!   parallel region whose single ends in a barrier that every thread of the team reaches
+! - vendor: "The barrier construct is supported." and "Implicit barriers are implemented." (NVIDIA HPC Compilers User's Guide 26.9,
+!   Using OpenMP, items 2.17.2 and 2.17.3), single is listed with its private, firstprivate and nowait clauses (item 2.8.2), and
+!   "Combined constructs are supported to the extent that the component constructs are themselves supported." (item 2.13;
+!   data/index/claims/nvidia-hpc-26.9-user-guide-openmp.txt)
+! - same-compiler control: controls/nvhpc-target-parallel-split-control.f90 (one change from this file; correct on nvhpc (NVHPC
+!   25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvc1/tuo.bar.jsonl, results/parity/nvc1/wt.bar.jsonl);
+!   controls/nvhpc-target-parallel-single-nowait-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11), nvhpc269
+!   (NVHPC 26.9); rows results/parity/nvc1/tuo.bar.jsonl, results/parity/nvc1/wt.bar.jsonl)
+! - other families: afar (AFAR 24.3.0) run the file correctly (rows results/parity/nvc1/tuo.bar.jsonl); cce19 (CCE 19.0.0), cce20
+!   (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4) fail it another way, e.g. `Creating internal compiler error backtrace
+!   (please wait):`
+! - variants: files next to the reduction in results/parity/nvc1/red/, rows results/parity/nvc1/wt.bar.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvc1/tuo.bar.jsonl: an explicit barrier
+!   (nvhpc-target-parallel-barrier-variant.f90) and the implicit barrier at the end of a worksharing loop
+!   (nvhpc-target-parallel-do-variant.f90) in the same combined construct time out too
+! - 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/nvc1/gate_abd.bar.jsonl, results/parity/nvc1/gate_abd.bar.m2.jsonl, results/parity/nvc1/gate_c.bar.jsonl,
+!   results/parity/nvc1/gate_c.bar.m2.jsonl, results/parity/nvc1/wt.bar.jsonl); campaign gate of the programs below: 20 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.127709.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.abd.127721.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.210952.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.210965.jsonl); the campaign gate's
+!   verdict is confirmed for all 20 cells; the other 18 were rerun in (b) and (c) only (timeouts are not rerun in every environment)
+! - programs (10): par-c1-nvhpc-nvhpc269:991, par-c1-nvhpc-nvhpc269:1182, par-c1-nvhpc-nvhpc269:1443, par-c1-nvhpc-nvhpc269:1678,
+!   par-c1-nvhpc-nvhpc269:1731, par-c1-nvhpc-nvhpc269:1762, par-c1-nvhpc-nvhpc269:1794, par-c1-nvhpc-nvhpc269:1805,
+!   par-c1-nvhpc-nvhpc269:2030, par-c1-nvhpc-nvhpc269:2228
+! - 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/nvc1/prerun.bar.txt); AFAR 24.3.0 runs all of them
+!   correctly
+!   with HSA_XNACK 0 and 1 (results/parity/nvc1/tuo.bar.jsonl). CCE 19/20/21/21.0.4 stop with an internal compiler error on single
+!   and barrier in a target region, their own documented failure (cce19-target-parallel-single-ice.f90), and run the
+!   worksharing-loop variant correctly. NVHPC is the compiler under test and is not counted as a witness
+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
+  !$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
+
+! site:
+! title: barrier in combined target parallel: hang
+! summary: nvfortran -mp=gpu appears to behave incorrectly on a barrier inside a combined target parallel construct (the end of a
+! + single or of a worksharing loop, or an explicit barrier): the program never finishes. The same region written as target
+! + containing parallel, or the single with nowait, finishes with the right result.
+! control: fuzz/controls/nvhpc-target-parallel-split-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-target-parallel-single-nowait-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! end site

offload/_root/data/findings/fuzz/nvhpc-target-simd-collapse-translate-failure.f90

@@ -0,0 +1,73 @@
+! # Finding (parity-fuzz-s1): NVHPC: a collapse clause on a combined target simd construct fails to translate ("Missing branch
+! # target block"); target containing simd collapse, or target simd without collapse, 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-W-0155-Compiler failed to translate accelerator region (see -Minfo messages): Missing branch target
+!   block (<tmpdir>/nvhpc-target-simd-collapse-translate-failure.f90: 10)` followed by `NVFORTRAN-F-0704-Compilation aborted due
+!   to previous errors.` (the rows' stderr; the harness's reason reads the F-0704 line); identical signature on 4 of 4 failing
+!   cells
+! - expected: compiles and prints `o1= -11.00` with `check=pass`
+! - rule: "The collapse clause associates one or more loops with the directive on which it appears for the purpose of
+!   identifying the portion of the depth of the canonical loop nest to which to apply the semantics of the directive." (5.2
+!   §4.4.3 p.93 l.23-25), whose directives are "distribute, do, for, loop, simd, taskloop" (5.2 §4.4.3 p.93 l.21), and "If
+!   directive-name-A is target then directive-name-B may be simd" (5.2 §17.3 p.342 l.22): collapse(2) on target simd applies the
+!   simd semantics to the two-loop nest
+! - vendor: "the simd construct is ignored for GPU targets" (item 2.9.3) and "Combined constructs are supported to the extent
+!   that the component constructs are themselves supported." (item 2.13); the collapse clause is listed as supported on the
+!   worksharing-loop, distribute and loop constructs (items 2.9.2, 2.9.4, 2.9.5) (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-target-simd-no-collapse-control.f90 (one change from this file; correct on nvhpc (NVHPC
+!   25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.bt.jsonl, results/parity/nvs1/wt.bt.jsonl);
+!   controls/nvhpc-target-simd-collapse-split-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11), nvhpc269
+!   (NVHPC 26.9); rows results/parity/nvs1/tuo.bt.jsonl, results/parity/nvs1/wt.bt.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.bt.jsonl)
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.bt.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.bt.jsonl: the same loop nest as target teams distribute simd
+!   collapse(2) (nvhpc-target-teams-distribute-simd-collapse-variant.f90) and as target parallel do simd collapse(2)
+!   (nvhpc-target-parallel-do-simd-collapse-variant.f90) compiles and is correct; target simd collapse(2) with a reduction
+!   (nvhpc-target-simd-collapse-reduction-variant.f90, the seed's shape) fails the same way. The seed's loop direction, complex
+!   output and reduction are irrelevant (exploration). The same message appears on n0x0/n1x0 seeds 847, 722 and 163
+!   (data/reports/fuzz-n0x0.md), not re-checked
+! - 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.bt.jsonl, results/parity/nvs1/gate_abd.bt.m2.jsonl, results/parity/nvs1/gate_c.bt.jsonl,
+!   results/parity/nvs1/gate_c.bt.m2.jsonl, results/parity/nvs1/wt.bt.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.2476695.jsonl,
+!   results/parity/wingtip/results/parity/gate/fuzz/reruns/wingtip.c.3482833.jsonl)
+! - programs (1): par-s1-nvhpc-nvhpc269:9796
+! - 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.bt.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.bt.jsonl). NVHPC is the compiler under
+!   test and is not counted as a witness
+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) collapse(2)
+  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
+
+! site:
+! title: collapse on target simd: translation failure
+! summary: nvfortran -mp=gpu appears to behave incorrectly on a combined target simd construct with a collapse clause: the
+! + compile stops with "Compiler failed to translate accelerator region: Missing branch target block". The same loop nest as
+! + target containing simd collapse(2), as target simd without collapse, or as target teams distribute simd collapse(2),
+! + compiles and runs correctly.
+! control: fuzz/controls/nvhpc-target-simd-no-collapse-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-target-simd-collapse-split-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! end site

offload/_root/data/findings/fuzz/nvhpc-target-simd-no-end-directive-rejected.f90

@@ -0,0 +1,68 @@
+! # Finding (parity-fuzz-s1): NVHPC: a combined target simd construct written without its optional end directive is rejected
+! # ("Illegal control structure - unterminated TARGET"); with the end directive, or as target containing simd, 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-S-0104-Illegal control structure - unterminated TARGET
+!   (<tmpdir>/nvhpc-target-simd-no-end-directive-rejected.f90: 6)`; identical signature on 4 of 4 failing cells
+! - expected: compiles and prints `suma= 152` with `check=pass`
+! - rule: "For a loop-associated directive, the paired end directive is optional." (5.2 §3.1 p.52 l.26) and "If directive-name-A
+!   is target then directive-name-B may be simd" (5.2 §17.3 p.342 l.22): the combined target simd construct is loop-associated
+!   through its simd leaf, so `!$omp end target simd` may be left out
+! - vendor: "the simd construct is ignored for GPU targets" (item 2.9.3) and "Combined constructs are supported to the extent
+!   that the component constructs are themselves supported." (item 2.13) (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-target-simd-end-directive-control.f90 (one change from this file; correct on nvhpc (NVHPC
+!   25.11), nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.ts.jsonl, results/parity/nvs1/wt.ts.jsonl);
+!   controls/nvhpc-target-simd-split-no-end-directive-control.f90 (one change from this file; correct on nvhpc (NVHPC 25.11),
+!   nvhpc269 (NVHPC 26.9); rows results/parity/nvs1/tuo.ts.jsonl, results/parity/nvs1/wt.ts.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.ts.jsonl)
+! - variants: files next to the reduction in results/parity/nvs1/red/, rows results/parity/nvs1/wt.ts.jsonl (both releases,
+!   separate and managed memory) and results/parity/nvs1/tuo.ts.jsonl: target parallel do
+!   (nvhpc-target-parallel-do-no-end-directive-variant.f90) and target teams distribute
+!   (nvhpc-target-teams-distribute-no-end-directive-variant.f90) without their end directives compile and are correct; with the
+!   seed's simdlen(16) (nvhpc-target-simd-simdlen-no-end-directive-variant.f90) the compile stops first at "SIMDLEN, not yet
+!   implemented". The s1 programs 888 and 3804 hold a target simd without its end directive, and in the campaign and its gate
+!   the two bundles hung in every environment on both releases (20 of 20 compiles, class compile_timeout, this rejection in the
+!   cells' stderr), so their cells carry another signature and are not counted here; one exploration compile of the 888 bundle
+!   outside the harness ended with the rejection in under 150 s, and the bundle with `!$omp end target simd` added compiles. Two
+!   other s1 bundles with this rejection do not hang: 8411 (counted below) and 3452, whose first diagnostic is SIMDLEN not
+!   implemented (not counted). The compile hang is an unreduced lead
+! - 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.ts.jsonl, results/parity/nvs1/gate_abd.ts.m2.jsonl, results/parity/nvs1/gate_c.ts.jsonl,
+!   results/parity/nvs1/gate_c.ts.m2.jsonl, results/parity/nvs1/wt.ts.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:8411 (a target simd with device, reduction and map(always) clauses and no end directive;
+!   both releases reject it with this message as the first diagnostic)
+! - 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.ts.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.ts.jsonl). NVHPC is the compiler under
+!   test and is not counted as a witness
+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
+  print '(a,i0)', 'suma= ', sum(a)
+  print '(a,a)', 'RESULT ran_on_host=0 check=', merge('pass', 'fail', sum(a) == 152)
+end program p
+
+! site:
+! title: target simd without end directive: rejected
+! summary: nvfortran -mp=gpu appears not to support a combined target simd construct written without its optional end directive:
+! + the compile stops with "Illegal control structure - unterminated TARGET". With `!$omp end target simd`, as target containing
+! + simd, or as target parallel do and target teams distribute without their end directives, it compiles and runs correctly.
+! control: fuzz/controls/nvhpc-target-simd-end-directive-control.f90 one change from the finding; correct on nvhpc, nvhpc269
+! control: fuzz/controls/nvhpc-target-simd-split-no-end-directive-control.f90 one change from the finding; correct on nvhpc,
+! + nvhpc269
+! end site

offload/_root/data/findings/fuzz/par-s1-2082-gcc_g90.f90

@@ -0,0 +1,71 @@
+! Minimized by compliance.fuzz_min from fuzz seed 2082 (fuzz-3), then reduced by hand (coverage parity review, 2026-10-29).
+! toolchain: gcc_g90 (-O2, HSA_XNACK=0, OMP_TARGET_OFFLOAD=mandatory)
+! failure: ice (ice: internal compiler error: in simplify_subreg, at simplify-rtx.cc:8291)
+! expected: compiles; prints `bad= 0` and `RESULT ran_on_host=0 check=pass`
+! observed: `internal compiler error: in simplify_subreg, at simplify-rtx.cc:8291` from the amdgcn offload compiler
+!   (accel/amdgcn-amdhsa/lto1, -march=gfx90a; in the RTL combine pass), located at the target directive (`!$omp target map(tofrom:
+!   host_flag)`, column 37); mkoffload and the link fail. Site matrix: the same on tioga39 in environments (a), (b), (d), and in (c)
+!   on another node. The nvptx build (gcc_sm80) compiles and runs this file correctly (mandatory pass 5 of 5; unset pass 5 of 5), as
+!   do AFAR, CCE 19/20/21/21.0.4 and NVHPC 25.11/26.9 in every site-matrix environment. Evidence:
+!   results/parity/tioga/gcc_g90/probes.jsonl, results/parity/wingtip/gcc_sm80/probes.jsonl, the site's finding matrix
+!   (data/vendor/checks/results-site), and the one-change probes under results/parity/probes-r2 (cptr_r4.f90: this program with one
+!   more, unused, integer variable).
+! control (compiles; correct on gcc_g90, mandatory pass 5 of 5, unset pass 5 of 5): the same program with `o1` a complex array
+!   instead of a pointer to one (controls/gcc-complex-pointer-store-control.f90). Other one-change probes on gcc_g90: a real
+!   pointer array compiles and runs correctly; so does storing the loop index `i` instead of `ic(i, 2)`; storing
+!   `mod(mod(ic(i, 2), 13), 1009)` (the fuzz program's expression), `cmplx(...)` or `real(ic(i, 2))`, with the loop ascending or
+!   descending, fails to compile too.
+! Legal OpenMP 5.2: the two witnesses that are neither GCC nor a compiler of this finding, offload.engine.rules and AFAR
+! flang's front
+!   end, accept this program and the control (offload.engine.prerun.check on results/parity/probes-r2/cptr_r4.f90 and
+!   cptr_ctl_array.f90, the same code with one more unused variable and no comments;
+!   results/parity/tioga/results/parity/legality.jsonl), and the minimized fuzz program before them; the fuzz program passed the
+!   campaign's legality gate (the same two witnesses). GCC is a compiler under test only and never a legality witness.
+program cptr_store
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 24
+  integer :: ic(n, 2), i, host_flag, bad
+  complex, pointer :: o1(:)
+  complex, target :: o1t(n)
+  o1 => o1t
+  do i = 1, n
+    ic(i, 1) = 0
+    ic(i, 2) = mod((i + 14) * 24 + 22, 101) - 1
+  end do
+  o1t = 0
+  host_flag = 1
+  !$omp target map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    do i = n, 1, -1
+      ! an integer array element stored into a complex pointer array
+      o1(i) = ic(i, 2)
+    end do
+  !$omp end target
+  bad = 0
+  do i = 1, n
+    if (o1t(i) /= cmplx(ic(i, 2), 0.0)) 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 cptr_store
+! site:
+! title: A complex pointer array written in a target region: internal compiler error in the amdgcn offload compiler
+! summary: GCC 16.2's amdgcn offload compiler (gfx90a) stops with an internal compiler error in its RTL combine pass on a
+! + target region that stores an integer array element into a complex pointer array. The same program with a complex array
+! + instead of the pointer compiles and runs correctly, and the A100 build of GCC compiles and runs this file. Reduced from a
+! + fuzz program.
+! control: fuzz/controls/gcc-complex-pointer-store-control.f90 o1 a complex array instead of a pointer
+! end site
+! spec (requirement): a pointer array that a target region references and no clause names is not a scalar, so it is mapped
+!   tofrom, and an associated pointer in a map clause maps its pointer target too, so storing through the pointer in the region is
+!   legal. The specification does not describe internal compiler errors, so no text covers the failure itself.
+! "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)
+! "If a list item in a map clause is an associated pointer and the pointer is not the base pointer of another list item in a map
+!   clause on the same construct, then it is treated as if its pointer target is implicitly mapped in the same clause. For the
+!   purposes of the map clause, the mapped pointer target is treated as if its base pointer is the associated pointer." (5.2
+!   §5.8.3 p.152 l.1-4)
+! spec (this program): the target region stores the integer elements ic(i, 2) into the complex pointer array o1 (pointer to
+!   o1t); GCC 16.2's amdgcn offload compiler (gfx90a) stops with an internal compiler error in the RTL combine pass instead of
+!   compiling the store, while a complex array in place of the pointer compiles.

offload/_root/data/findings/fuzz/s1-2370-cce21.f90

@@ -0,0 +1,67 @@
+! Finding: CCE 19, 20, 21 reject firstprivate(i) on a combined
+! parallel do nested in a teams distribute loop over i, under default(none)
+! (ftn-1510 "Variable "I" must have its data scope explicitly declared
+! because DEFAULT(NONE) was specified"; in other programs ftn-1310 "Object
+! "I" is specified on the FIRSTPRIVATE clause. It must have a shared scope
+! in the enclosing region").
+!
+! Legal OpenMP 5.2: firstprivate on a combined construct applies to the
+! worksharing leaf, and "If the parallel construct is among the constituent
+! constructs and the effect is not as if the firstprivate clause is applied
+! to it by the above rules, then the effect is as if the shared clause with
+! the same list item is applied to the parallel construct" (5.2 §17.2
+! p.340), so i is shared in the parallel region (default(none) is
+! satisfied, 5.2 §5.4.1 p.109) and the restriction on worksharing
+! firstprivate items that are private in the binding parallel region (5.2
+! §5.4.4) does not apply; in the teams region i is the iteration variable of
+! the distribute loop, predetermined private ("The loop iteration variable
+! in any associated loop of a loop-associated construct is otherwise
+! private", 5.2 §5.1.1 p.97). (A gfortran -fopenmp accept is withdrawn as evidence, 2026-10-23.)
+! Expected: "RESULT check=pass" (a(i, j) = 10 * i + j).
+!
+! Observed (tuolumne, MI300A, -O2, HSA_XNACK=1, 2026-10-23,
+! results/t28_probe/dn_teams_loopvar*.json):
+! - CCE 19.0.0, 20.0.2, 21.0.3: ftn-1510 for I at the firstprivate(i) of
+!   the parallel do; without firstprivate(i) (data/evidence/dataenv_probe/
+!   dn_teams_loopvar_nofp.f90) all three compile and run correctly;
+! - AFAR amdflang 24.0.0git: "RESULT check=pass".
+! - Tioga MI250X (gfx90a, HSA_XNACK=0): the same; CCE 19/20/21 reject,
+!   AFAR passes (results/t28_probe/g90/dn_teams_loopvar.cce21_g90.json).
+! Fuzz campaign s1: the ftn-1510 "I" and ftn-1310 "I" cells of CCE (rule
+! R11, decisions D2 and D5), verdict compiler_bug. Representatives: s1
+! seeds 2370 (cce21, copy) and 6443 (cce21); reproducer written by hand
+! (data/evidence/dataenv_probe/dn_teams_loopvar.f90).
+!
+! ftn -fopenmp -O2
+program p
+  implicit none
+  integer, parameter :: n = 8, m = 4
+  integer :: a(n, m), i, j
+  logical :: ok
+  a = 0
+  !$omp target map(tofrom: a)
+  !$omp teams distribute default(none) shared(a) private(j)
+  do i = 1, n
+    !$omp parallel do default(none) shared(a) firstprivate(i)
+    do j = 1, m
+      a(i, j) = 10 * i + j
+    end do
+  end do
+  !$omp end teams distribute
+  !$omp end target
+  ok = .true.
+  do i = 1, n
+    do j = 1, m
+      ok = ok .and. a(i, j) == 10 * i + j
+    end do
+  end do
+  if (ok) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a)', 'RESULT check=fail'
+  end if
+end program p
+! site:
+! title: ftn: firstprivate(i) on a parallel do nested in a teams distribute loop over i rejected under default(none) (ftn-1510)
+! control: ../vendor/checks/src/other/control/s1-2370-cce21-control.f90 firstprivate(i) removed from the parallel do
+! end site

offload/_root/data/findings/fuzz/s1-2592-cce21.f90

@@ -0,0 +1,56 @@
+! Finding: CCE 19, 20, 21 internal compiler error "Should never
+! reach this code (doehmke)" (v_mt_util_misc.c; line 2697 in 19.0.0, 2711
+! in 20.0.2, 2719 in 21.0.3) on a target region with in_reduction(*: r),
+! inside taskgroup task_reduction(*: r), that reads a substring of a
+! character dummy (ichar(xs(1:1))). With a constant instead of the
+! substring all three compile (data/evidence/dataenv_probe/ice/e2.f90).
+!
+! Legal OpenMP 5.2: in_reduction on target (5.2 §5.5.10), task_reduction on
+! taskgroup (§5.5.9), a character dummy referenced in the region (mapped
+! implicitly). (A gfortran -fopenmp accept is no evidence: owner, 2026-10-23.) Expected: ichar('k') =
+! 107 and mod(107, 13) = 3, so every factor is 1 and r stays -1: "RESULT
+! check=pass".
+!
+! Observed (tuolumne, MI300A, -O2, HSA_XNACK=1 and 0, 2026-10-23,
+! results/t28_probe/ice_inred_char_substring.f90.*.json):
+! - CCE 19.0.0, 20.0.2, 21.0.3: the ICE above, both modes;
+! - AFAR amdflang 24.0.0git: "RESULT check=pass" in both modes;
+! - Tioga MI250X (gfx90a, HSA_XNACK=0): CCE 21 the same ICE
+!   (results/t28_probe/g90/ice_inred_char_substring.cce21_g90.json).
+! Fuzz campaign s1: the "Should never reach this code (doehmke)" cells of
+! CCE 19/20/21. Representative s1 seed 2592 on cce21; the confirmer's
+! reduction (results/confirm/drafts/fuzz_s1_2592_cce21_gfx942_unified,
+! 189 -> 98 lines, ICE kept) reduced further by hand.
+!
+! ftn -fopenmp -O2
+program p
+  implicit none
+  integer, parameter :: n = 16
+  character(len=8) :: xs
+  integer :: r
+  xs = 'kPACnWLl'
+  r = -1
+  call kp1(xs)
+  if (r == -1) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a,i0)', 'RESULT check=fail r=', r
+  end if
+contains
+  subroutine kp1(xs)
+    character(len=*), intent(in) :: xs
+    integer :: i
+    !$omp taskgroup task_reduction(*: r)
+      !$omp target defaultmap(tofrom: scalar) in_reduction(*: r)
+        do i = 1, n
+          r = r * merge(-1, 1, mod(ichar(xs(1:1)), 13) == 0)
+        end do
+      !$omp end target
+    !$omp end taskgroup
+  end subroutine kp1
+end program p
+! site:
+! title: ftn: internal compiler error "Should never reach this code (doehmke)" for in_reduction on target reading a character
+! + substring
+! control: ../vendor/checks/src/other/control/s1-2592-cce21-control.f90 ichar('k') instead of ichar(xs(1:1))
+! end site

offload/_root/data/findings/fuzz/s1-3463-cce21.f90

@@ -0,0 +1,92 @@
+! Finding: CCE 19, 20, 21 internal compiler error "Error getting
+! dope vector information" (v_dope_utl.c; line 931 in 19.0.0, 933 in
+! 20.0.2, 935 in 21.0.3) on a target construct in an internal subroutine
+! that maps components of a structure dummy (dr%a, dr%nd%k(1:n)) together
+! with host-associated variables (an allocatable array, scalars), in a
+! program with a default declare mapper for another type.
+!
+! Legal OpenMP 5.2 (structure components and array sections of them are
+! map list items, 5.2 §5.8.3; host-associated variables in a map clause).
+! Legality: 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. AFAR compiles and runs the
+! unreduced program.
+!
+! : hand reductions that drop the unused module, types
+! and dummies no longer show the ICE (it needs parts that look unused); the
+! vendor packet uses this generated program.
+!
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/icev2.log):
+! the confirmer's reduction of s1 seed 3463 (results/confirm/drafts/
+! fuzz_s1_3463_cce21_gfx942_unified, 252 -> 161 lines, ICE site kept)
+! gives the ICE on CCE 19, 20 and 21; this file is that program reduced
+! further on CCE 21 by deleting lines while the ICE stays
+! (data/evidence/dataenv_probe/min_ice.py; 161 -> 106 lines). A hand-written form with
+! only the structure dummy's component maps compiles
+! (data/evidence/dataenv_probe/ice/d1.f90), so the trigger is not reduced further.
+! Fuzz campaign s1: the "Error getting dope vector information" cells of
+! CCE 19/20/21.
+!
+! Fix: reduced further by clause and list-item
+! deletion as well as lines (data/evidence/dataenv_probe/min_ice.py, 106 -> 49 lines,
+! results/t28_probe/short/); the ICE stays on CCE 19, 20 and 21 at their
+! v_dope_utl.c sites and AFAR compiles it (results/t28_probe/icev_fr1.log).
+! The remaining program: an internal subroutine with a target construct
+! mapping dr%nd%k(1:n) of a structure dummy, next to an unused internal
+! subroutine with a character(len=*) dummy, an optional assumed-shape
+! dummy and complex dummies, and a module declare reduction; removing any
+! of these makes the ICE go away.
+!
+! ftn -fopenmp -O2 (a bundle: 
+!@file fuzz_dmod.f90
+module fuzz_dmod
+  implicit none
+  type :: mt_t
+  end type mt_t
+  type :: pair_t
+    integer :: x, y
+  end type pair_t
+  !$omp declare reduction(padd: pair_t: omp_out = pair_t(omp_out%x + omp_in%x, omp_out%y + omp_in%y)) &
+  !$omp& initializer(omp_priv = pair_t(0, 0))
+contains
+end module fuzz_dmod
+!@file fuzz_prog.f90
+program fuzz_prog
+  use omp_lib, only: omp_get_team_num, omp_get_thread_num, omp_is_initial_device
+  use fuzz_dmod
+  implicit none
+  integer, parameter :: n = 48, m = 8
+  type :: nd_t
+    integer :: k(n)
+  end type nd_t
+  type :: rec_t
+    type(nd_t) :: nd
+  end type rec_t
+contains
+  subroutine kp2(ia, ib, ic, xs, xz4, xz8, dr, ms, zopt)
+    integer, intent(inout) :: ia(:)
+    integer, intent(in) :: ib(:)
+    integer, intent(in) :: ic(n, m)
+    character(len=*), intent(in) :: xs
+    complex, intent(in) :: xz4(n)
+    complex(kind=8), intent(in) :: xz8(n)
+    type(rec_t), intent(inout) :: dr
+    type(mt_t), intent(inout) :: ms
+    integer, intent(in), optional :: zopt(:)
+  end subroutine kp2
+  subroutine kp3(ia, ib, o3, xc, dr)
+    integer, intent(inout) :: ia(n)
+    integer, intent(in) :: ib(n)
+    integer, intent(inout) :: o3(n)
+    character(len=4), intent(inout) :: xc(n)
+    type(rec_t), intent(inout) :: dr
+    !$omp target map(dr%nd%k(1:n))
+      if (omp_get_team_num() == 0) then
+      end if
+    !$omp end target
+  end subroutine kp3
+end program fuzz_prog
+! site:
+! title: ftn: internal compiler error "Error getting dope vector information" mapping a component section of a structure dummy
+! control: ../vendor/checks/src/other/control/s1-3463-cce21-control.f90 the map clause dropped from the target construct
+! end site

offload/_root/data/findings/fuzz/s1-4339-afar.f90

@@ -0,0 +1,79 @@
+! Finding: AFAR at HSA_XNACK=1 aborts (SIGABRT; in
+! the campaign "OFFLOAD ERROR: memory access fault by GPU ... Write access
+! to a read-only page") on a target construct with map(close, tofrom: ia)
+! for an allocatable dummy ia that the region does not even reference,
+! while the region reads another assumed-shape dummy (dsi, implicitly
+! mapped tofrom). AFAR at HSA_XNACK=0 and CCE 19/20/21 in both modes print
+! "RESULT check=pass".
+!
+! Legal OpenMP 5.2: close is a map-type modifier that is a hint ("The close
+! map-type-modifier is a hint to the runtime to allocate memory close to
+! the target device", 5.2 §5.8.3 p.155 l.12); an
+! assumed-shape dummy referenced in the region is mapped tofrom implicitly
+! (5.2 §5.8.1).
+!
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/close/
+! c4339_*.f90.*.json): this program (c4339_c) aborts on AFAR at
+! HSA_XNACK=1 on every run and passes at HSA_XNACK=0; without close
+! (c4339_b) it passes; with an explicit-shape ia (c4339_d) it passes; with
+! the region reading ia instead of the other dummy (c4339_e) it passes; the
+! derived-type dummy of the reduction (c4339_a) aborts the same way. The
+! close + present abort of fuzz/158-afar.f90 is another symptom of AFAR's
+! close handling at HSA_XNACK=1 (no present modifier here).
+! From s1 seed 4339 (the smallest program of the s1 group "AFAR memory
+! access fault", 59 compiler_bug cells): tools/campaigns/fuzz.py minimize-one,
+! 141 -> 91 lines (data/evidence/dataenv_probe/rt/4339-afar.f90), then by hand.
+! Expected: "RESULT check=pass".
+!
+! amdflang -fopenmp --offload-arch=gfx942 -O2 (afar recipe, offload/engine/toolchains.py)
+module mm
+  implicit none
+  integer, parameter :: n = 128
+  type :: el_t
+    integer :: u
+  end type el_t
+contains
+  subroutine kp1(ia, o1, dsi)
+    integer, allocatable, intent(inout) :: ia(:)
+    integer, intent(inout) :: o1(:)
+    integer, intent(in) :: dsi(:)
+    integer :: i
+    !$omp target map(close, tofrom: ia) map(tofrom: o1)
+      do i = 1, n
+        o1(i) = dsi(i)
+      end do
+    !$omp end target
+  end subroutine kp1
+end module mm
+program p
+  use mm
+  implicit none
+  type(el_t) :: ds(n)
+  integer :: dsi(n)
+  integer, allocatable :: ia(:)
+  integer, pointer :: o1(:)
+  integer :: i
+  logical :: ok
+  allocate(ia(n))
+  ia = 1
+  allocate(o1(n))
+  do i = 1, n
+    dsi(i) = mod(i * 26 + 31, 97) - 21
+  end do
+  o1 = 0
+  call kp1(ia, o1, dsi)
+  ok = .true.
+  do i = 1, n
+    ok = ok .and. o1(i) == mod(i * 26 + 31, 97) - 21
+  end do
+  if (ok) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a)', 'RESULT check=fail'
+  end if
+end program p
+! site:
+! title: AFAR offload runtime at HSA_XNACK=1: map(close, ...) breaks presence lookup and device access (abort, memory fault)
+! control: ../vendor/checks/src/other/control/s1-4339-afar-control.f90 map(tofrom: ia) without the close modifier
+! same_as: fuzz/s1-9443-afar
+! end site