offtarget 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,96 @@
+! Finding: CCE 20 and 21 internal compiler error: optcg killed by
+! signal 6 (ftn-2116 "optcg was terminated due to receipt of signal 06:
+! Aborted") on a program with a target teams loop that maps a pointer
+! component (map(always, tofrom: dr%pc)) and reduces with a user-defined
+! reduction (reduction(padd: rp2a), declare reduction padd for a derived
+! type), next to a target teams region with map(tofrom: dr) and
+! reduction(min: r1a). CCE 19 does not implement user-defined reductions
+! in target regions (not_implemented, a support gap).
+!
+! Legal OpenMP 5.2 (declare reduction §5.5.11 and its use on teams/loop,
+! §5.5.8; a pointer component in a map clause, §5.8.3). 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.
+!
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/icev2.log):
+! the confirmer's reduction of s1 seed 6085 (results/confirm/drafts/
+! fuzz_s1_6085_cce21_gfx942_unified, 216 -> 179 lines, ICE kept) gives the
+! optcg abort on CCE 20 and 21; this file is that program reduced further
+! on CCE 21 by deleting lines while the abort stays
+! (data/evidence/dataenv_probe/min_ice.py; 179 -> 130 lines). Hand-written forms of
+! the two kernels alone do not reproduce it (data/evidence/dataenv_probe/ice/b1-b3.f90:
+! CCE reports "Unsupported OpenMP construct Calls -- __GET_DYNAMIC_TYPE" or
+! compiles). Fuzz campaign s1: the ftn-2116 signal 06 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, 130 -> 56 lines,
+! results/t28_probe/short/): two empty target teams constructs, one with
+! map(tofrom: dr) (a structure with an allocatable component) and
+! reduction(min: r1a), one a target teams loop with the user reduction
+! reduction(padd: rp2a), and a module procedure in a submodule; the optcg
+! abort stays on CCE 20 and 21, CCE 19 reports user reductions not
+! implemented, AFAR compiles it (results/t28_probe/icev_fr1.log).
+!
+! 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))
+end module fuzz_dmod
+!@file fuzz_smod.f90
+module fuzz_smod
+  implicit none
+  interface
+    module integer function gs1(x)
+      integer, intent(in) :: x
+    end function gs1
+  end interface
+end module fuzz_smod
+!@file fuzz_ssub.f90
+submodule (fuzz_smod) fuzz_ssub
+  implicit none
+contains
+  module integer function gs1(x)
+    integer, intent(in) :: x
+  end function gs1
+end submodule fuzz_ssub
+!@file fuzz_prog.f90
+program fuzz_prog
+  use fuzz_dmod
+  implicit none
+  integer, parameter :: n = 100, m = 5
+  type :: rec_t
+    integer, allocatable :: o1(:)
+  end type rec_t
+  type(pair_t) :: rp2a
+  integer :: i, r1a
+contains
+  subroutine kp1(xr4, dr)
+    real(4), allocatable, intent(in) :: xr4(:)
+    type(rec_t), intent(inout) :: dr
+    !$omp target teams map(tofrom: dr) reduction(min: r1a)
+    !$omp end target teams
+  end subroutine kp1
+  subroutine kp2(ic, xk1, xr4, dr, ms)
+    integer, intent(inout) :: ic(:, :)
+    integer(1), allocatable, intent(in) :: xk1(:)
+    real(4), intent(in) :: xr4(:)
+    type(rec_t), intent(inout) :: dr
+    type(mt_t), intent(inout) :: ms
+    !$omp target teams loop reduction(padd: rp2a)
+    do i = 1, n
+    end do
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: craycc/ftn: OpenMP 5.1/5.2/6.0 forms HPE does not claim are rejected, and some crash the compiler instead of a diagnostic
+! control: ../vendor/checks/src/other/control/s1-6085-cce21-control.f90 reduction(min: r1a) removed from the first target teams
+! same_as: catalog/cce-c-map-iterator-ice
+! end site

offload/_root/data/findings/fuzz/s1-6760-cce20.f90

@@ -0,0 +1,65 @@
+! Finding: CCE 20 rejects the enter clause of declare
+! target (ftn-1725 "Unexpected syntax while parsing the DIRECTIVE statement :
+! "INDIRECT, LINK, TO or DEVICE_TYPE" was expected but found "E"").
+!
+! Legal OpenMP 5.2: enter is the 5.2 name of the declare target clause that
+! 5.0/5.1 spell to ("The clause-name to may be used as a synonym for the
+! clause-name enter. This use has been deprecated.", 5.2 §5.8.4 p.158; "The
+! enter clause was added as a synonym for the to clause on the declare
+! target directive", 5.2 Appendix B.2 p.627). CCE 20 claims it: the CCE
+! 20.0.0 release notes list "[5.2] ... misc. new syntax allowed by
+! specification (e.g. `declare target`, `ordered`, metadirective)", and
+! the only new 5.2 syntax of declare target is enter (catalog/omp/
+! claims.yaml; maintainer reading). A claimed form
+! rejected: compiler_bug. CCE 19 makes no such claim (its identical
+! rejection is unsupported, rule R11c); CCE 21 claims enter (Fortran) and
+! accepts it.
+!
+! Observed (tuolumne, MI300A, -O2, HSA_XNACK=1 and 0, 2026-10-23,
+! results/t28_probe/dt_enter.f90.*.json): CCE 20.0.2 ftn-1725 at the enter
+! keyword (dt_enter.f90 line 13, column 24); CCE 19.0.0 the same
+! (unsupported, no claim); CCE 21.0.3 and AFAR amdflang 24.0.0git compile
+! it and print "RESULT check=pass" in both modes. Tioga MI250X (gfx90a):
+! the catalog program omp52-clause-enter is rejected the same way by
+! cce20_g90 (results/confirm/batch_full.jsonl, R11).
+! Fuzz campaign s1: CCE 20's 7,099 enter rejections (s1 and s1x0; 5,588
+! s1 programs use enter) are compiler_bug: 4,502 by rule R11 (another
+! family compiles the program) and 2,597 by decision D9 (the other
+! families reject the program at other statements). Representative: s1
+! seed 6760 (116 lines, AFAR and CCE 21 print the model value); this
+! reproducer is written by hand (data/evidence/dataenv_probe/dt_enter.f90).
+! Expected: "RESULT check=pass".
+!
+! ftn -fopenmp -O2 (cce20 recipe, offload/engine/toolchains.py)
+module m
+  implicit none
+  integer, parameter :: n = 16
+  integer :: g(n) = 1
+  !$omp declare target enter(g)
+end module m
+program p
+  use m
+  implicit none
+  integer :: i
+  logical :: ok
+  !$omp target
+  do i = 1, n
+    g(i) = g(i) + i
+  end do
+  !$omp end target
+  !$omp target update from(g)
+  ok = .true.
+  do i = 1, n
+    ok = ok .and. g(i) == 1 + i
+  end do
+  if (ok) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a)', 'RESULT check=fail'
+  end if
+end program p
+! site:
+! title: ftn rejects the enter clause of declare target (the OpenMP 5.2 name of the to clause)
+! control: ../vendor/checks/src/other/control/s1-6760-cce20-control.f90 declare target to(g), the deprecated spelling, instead of
+! + enter(g)
+! end site

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

@@ -0,0 +1,76 @@
+! Finding: CCE 19, 20, 21 reject a strided array section in a
+! motion clause of target update (ftn-1747 "The stride specified for array
+! ... must not be greater than 1. Subarray references in the MAP clause
+! must be to contiguous memory").
+!
+! Legal OpenMP 5.0-5.2: "A stride expression may not be specified unless
+! otherwise stated" (5.2 §3.2.5 p.66) and the data-motion clauses state it:
+! "The list items may include array sections with stride expressions"
+! (5.2 §5.9 p.165); added in 5.0: "The target update construct (see Section
+! 13.9) was modified to allow array sections that specify discontiguous
+! storage" (5.2 §B.4 p.634). Only the map clause requires contiguous storage
+! (5.2 §5.8.3 p.156). CCE claims full OpenMP 5.0 (intro_openmp(7) of 19.0.0,
+! 20.0.2, 21.0.3). gfortran 13 rejects it too ("Stride should not be
+! specified for array section in TO clause"): a limitation of gfortran, not
+! a legality verdict. AFAR prints "error: stride cannot be specified on an
+! array section" for strided sections of structure components (e.g.
+! gs%k(1:n:2)); in s1 and s1x0 289 AFAR cells carry it and none of them
+! agrees (194 compile_reject, 68 run_error, 17 wrong_code, 10 ICE), against
+! 54% agree for the cells without it, and 22 of AFAR's 138 present-modifier
+! aborts are among them (8 times the overall rate). The message is not
+! always fatal; an AFAR defect with strided component sections is likely
+! but was not reduced in this task. For a plain array, as here, AFAR is
+! silent and correct.
+! Expected: "RESULT check=pass" (the odd elements are doubled on the device
+! and copied back; the even ones are not checked, since they depend on the
+! memory mode).
+!
+! Observed (tuolumne, MI300A, -O2, HSA_XNACK=1 and 0, 2026-10-23,
+! results/t28_probe/strided_update.f90.*.json):
+! - CCE 19.0.0, 20.0.2, 21.0.3: compile error ftn-1747 at the target update
+!   (21.0.3 words it "... in the MAP clause must not be greater than 1.");
+! - AFAR amdflang 24.0.0git: compiles, "RESULT check=pass" in both modes.
+! - Tioga MI250X (gfx90a, HSA_XNACK=0): the same; CCE 19/20/21 reject,
+!   AFAR passes (results/t28_probe/g90/strided_update.cce21_g90.json).
+! Fuzz campaign s1: 988 CCE cells (s1 and s1x0) fail on this diagnostic,
+! verdict compiler_bug (rule R11 where AFAR compiles the program, decision
+! D1 where every family rejects the program at different statements).
+! Representative: s1 seed 6888 on cce21 (the confirmer's reduction,
+! results/confirm/drafts/fuzz_s1_6888_cce21_gfx942_unified, keeps
+! "!$omp target update to(gs%k(1:n:2))"); reproducer written by hand from
+! it (data/evidence/dataenv_probe/strided_update.f90).
+!
+! ftn -fopenmp -O2 (cce19/cce20/cce21 recipes, offload/engine/toolchains.py)
+program p
+  implicit none
+  integer, parameter :: n = 16
+  integer :: a(n), i
+  logical :: ok
+  a = 0
+  !$omp target enter data map(to: a)
+  do i = 1, n
+    a(i) = i
+  end do
+  !$omp target update to(a(1:n:2))
+  !$omp target
+  do i = 1, n
+    a(i) = 2 * a(i)
+  end do
+  !$omp end target
+  !$omp target exit data map(from: a)
+  ok = .true.
+  do i = 1, n
+    ! the even elements are 0 with separate memory and 2 * i with
+    ! shared memory: only the updated ones are checked
+    if (mod(i, 2) == 1) ok = ok .and. a(i) == 2 * i
+  end do
+  if (ok) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a)', 'RESULT check=fail'
+  end if
+end program p
+! site:
+! title: ftn: target update to(a(1:n:2)) rejected (ftn-1747, stride must not be greater than 1)
+! control: ../vendor/checks/src/other/control/s1-6888-cce21-control.f90 to(a(1:n)), without the stride (all elements updated)
+! end site

offload/_root/data/findings/fuzz/s1-7882-cce20.f90

@@ -0,0 +1,63 @@
+! Minimized by compliance.fuzz_min from fuzz seed 7882 (fuzz-3).
+! toolchain: cce20 (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (exit_status)
+! message: Variable not found in present table
+! expected: runs to completion (the host run does)
+! observed: device: fail exit_status: 1; host reference (afar) checksum=0
+! Legal OpenMP 5.2: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+!   race rule and the restriction checks, and the AFAR flang front end, not under test here); no
+!   compiler under test, gfortran or gcc is a legality witness.
+! also fails on: cce19, cce21
+! Finding: CCE 19, 20, 21 end with exit status 1 ("Variable not
+! found in present table", the CCE runtime's present check) at a target
+! construct with map(present, tofrom: xc) for a character array xc that the
+! enclosing target data construct maps (map(to: ... xc ...)); AFAR runs it.
+! Legal OpenMP 5.2: the target data construct makes xc present, so the
+! present modifier is satisfied (5.2 §5.8.3 p.152 l.25-27: "If a map clause with a
+! present map-type-modifier appears on a construct and on entry to the
+! region the corresponding list item is not present in the device data
+! environment, runtime error termination is performed"); a
+! character array is a map list item. Related to s1-8634-cce21.f90 (CCE ICE
+! on a character scalar in enter/exit data): another construct and
+! symptom (an array, a run-time presence failure).
+! Observed (tuolumne, MI300A, -O2, HSA_XNACK=1 and 0, 2026-10-23,
+! results/t28_probe/rt/7882-cce20.f90.*.json): CCE 19, 20, 21 exit status 1
+! in both modes; AFAR "RESULT checksum=0" (the reference). Reduced from s1
+! seed 7882 by tools/campaigns/fuzz.py minimize-one (197 -> 84 lines).
+! Shorter form (fix; written by hand from
+! the 84-line reduction, which git history keeps): an allocatable
+! character(len=4) array alone in target data map(to: xc) and an inner
+! target map(present, tofrom: xc) (data/evidence/dataenv_probe/short/c7882_a.f90).
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/short/
+! c7882_a.f90.*.json): CCE 19, 20, 21 exit status 1 ("Variable not found in
+! present table") in both modes; AFAR "RESULT check=pass" in both modes.
+! With a fixed-size character array (c7882_b) only CCE 19 fails; with
+! other items in the target data list (c7882_c, c7882_d) all three fail.
+! Expected: "RESULT check=pass".
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 48
+  character(len=4), allocatable :: xc(:)
+  integer :: i, hf1
+  allocate(xc(n))
+  do i = 1, n
+    xc(i) = achar(65 + mod(i * 33, 26)) // 'b#c'
+  end do
+  hf1 = -1
+  !$omp target data map(to: xc)
+    !$omp target map(present, tofrom: xc) map(tofrom: hf1)
+      hf1 = merge(1, 0, omp_is_initial_device())
+    !$omp end target
+  !$omp end target data
+  if (hf1 == 0) then
+    print '(a)', 'RESULT check=pass'
+  else
+    print '(a)', 'RESULT check=fail'
+  end if
+end program p
+! site:
+! title: ftn: map(present, tofrom: xc) of an allocatable character array mapped by the enclosing target data stops with "Variable
+! + not found in present table"
+! control: ../vendor/checks/src/other/control/s1-7882-cce20-control.f90 map(tofrom: xc) without the present modifier
+! end site

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

@@ -0,0 +1,45 @@
+! Finding: CCE 19, 20, 21 crash (internal compiler error) on a
+! character scalar in the map clause of a standalone target enter data or
+! target exit data construct. In this smallest form optcg is killed by
+! signal 11 (ftn-2116 "optcg was terminated due to receipt of signal 013:
+! Segmentation fault"); in larger programs the same statements give
+! "Unhandled expression type in get base or dv mem" (s1 seed 8634; with a
+! derived-type variable and an internal subroutine in the program,
+! data/evidence/dataenv_probe/ice/a5.f90 gives it on CCE 19, 20 and 21) or
+! "unexpected type in TYPE_DEREF" (s1 seed 2952 on CCE 21). Character
+! arrays in the same constructs compile (data/evidence/dataenv_probe/ice/c2.f90).
+!
+! Legal OpenMP 5.2: a character scalar is a variable list item of map
+! (5.2 §5.8.3; the enter and exit data constructs take map clauses, §13.6,
+! §13.7). (A gfortran -fopenmp accept is no evidence: owner, 2026-10-23.) Expected: "RESULT
+! check=pass".
+!
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/icev3.log
+! and icev.log; data/evidence/dataenv_probe/ice/c1.f90 is this program):
+! - CCE 19.0.0, 20.0.2, 21.0.3: ftn-2116, optcg killed by signal 11; the
+!   same with map(delete: xs) on exit data alone
+!   (data/evidence/dataenv_probe/ice_char_exit_delete.f90);
+! - AFAR amdflang 24.0.0git: compiles and prints "RESULT check=pass".
+! - Tioga MI250X (gfx90a, HSA_XNACK=0): CCE 21 the same ICE
+!   (results/t28_probe/g90/ice_char_exit_delete.cce21_g90.json).
+! Fuzz campaign s1: the "Unhandled expression type in get base or dv mem"
+! and "unexpected type in TYPE_DEREF" ICE cells of CCE 19/20/21 (most of
+! those programs map character scalars and arrays in target enter data;
+! not every one was reduced). The confirmer's reduction of seed 8634
+! (results/confirm/drafts/fuzz_s1_8634_cce21_gfx942_unified, 151 -> 76
+! lines, ICE site kept) keeps "!$omp target exit data map(delete: xs)" of
+! character(len=8) :: xs; this file is reduced from it by hand.
+!
+! ftn -fopenmp -O2
+program p
+  implicit none
+  character(len=8) :: xs
+  xs = 'abcdefgh'
+  !$omp target enter data map(to: xs)
+  !$omp target exit data map(release: xs)
+  print '(a)', 'RESULT check=pass'
+end program p
+! site:
+! title: ftn: internal compiler error (optcg signal 11) for a character scalar in target enter data / exit data
+! control: ../vendor/checks/src/other/control/s1-8634-cce21-control.f90 a character array xs(2) instead of a character scalar
+! end site

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

@@ -0,0 +1,92 @@
+! Finding: CCE 21 (and CCE 19/20 in the campaign) reports ftn-1510
+! "Variable "HF2" must have its data scope explicitly declared because
+! DEFAULT(NONE) was specified" for an assignment in a target region of the
+! internal subroutine kp2, which has no default clause anywhere: the
+! default(none) is on an (empty) parallel construct in a sibling internal
+! subroutine kp1.
+!
+! Legal OpenMP 5.2: default(none) restricts only "each variable that is
+! referenced in the construct" (5.2 §5.4.1 p.109); hf2 is referenced only
+! in kp2's target region, which has no default 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. (CCE also has the known ICE for masked in a target
+! region, cce19-target-parallel-single-ice.f90; this diagnostic comes
+! first.)
+!
+! : hand reductions that drop the unused module, types
+! and dummies no longer show ftn-1510, and the program also needs the masked
+! construct, which CCE documents as unsupported in offload regions; the vendor
+! packet uses this generated program.
+!
+! Observed (tuolumne, -O2, 2026-10-23): CCE 21.0.3 ftn-1510 for HF2 at
+! the assignment. Fuzz campaign s1: the ftn-1510 cells of CCE 19/20/21 for
+! variables other than a loop's iteration variable (decision D3; R11 where
+! AFAR compiles). Representative s1 seed 91 (cce21, copy mode; compile
+! only): the confirmer's reduction (results/confirm/drafts/
+! fuzz_s1_91_cce21_gfx942_copy, 223 -> 148 lines) reduced further by
+! deleting lines while the diagnostic stays (data/evidence/dataenv_probe/min_ice.py,
+! 148 -> 61 lines). A hand-written two-subroutine form without the
+! structure maps compiles (it ICEs on the masked construct instead), so
+! the trigger is not reduced further.
+!
+! Fix: the empty fuzz_ext file is gone and the
+! program is reduced further by clause and list-item deletion as well as
+! lines (data/evidence/dataenv_probe/min_ice.py, 61 -> 41 lines, results/t28_probe/
+! short/): kp1 holds an empty parallel default(none) in a target region,
+! its sibling kp2 a target region whose masked construct assigns hf2; CCE
+! 21 reports ftn-1510 for HF2, CCE 19 and 20 stop earlier at their ICE for
+! masked in a target region (results/t28_probe/icev_fr1.log); AFAR
+! compiles it. kp2's unused dummies stay because min_ice does not edit
+! argument lists.
+!
+! ftn -fopenmp -O2 (a bundle: 
+!@file fuzz_dmod.f90
+module fuzz_dmod
+  implicit none
+  type :: mt_t
+  end type mt_t
+end module fuzz_dmod
+!@file fuzz_prog.f90
+program fuzz_prog
+  use omp_lib, only: omp_is_initial_device
+  use fuzz_dmod
+  implicit none
+  type :: rec_t
+  end type rec_t
+  type(rec_t) :: dr
+  integer :: hf2
+  !$omp target data map(tofrom: dr)
+  !$omp end target data
+contains
+  subroutine kp1(dr)
+    type(rec_t), intent(inout) :: dr
+    !$omp target 
+      !$omp parallel default(none)
+      !$omp end parallel
+    !$omp end target
+  end subroutine kp1
+  subroutine kp2(ia, ic, xk1, xr8, dr, ms, p2)
+    integer, intent(inout) :: ia(:)
+    integer, allocatable, intent(inout) :: ic(:, :)
+    integer(kind=1), intent(inout) :: xk1(:)
+    real(kind=8), intent(in) :: xr8(:)
+    type(rec_t), intent(inout) :: dr
+    type(mt_t), intent(inout) :: ms
+    integer, intent(in), optional :: p2
+    !$omp target &
+    !$omp& map(tofrom: hf2)
+      !$omp masked
+        hf2 = merge(1, 0, omp_is_initial_device())
+      !$omp end masked
+    !$omp end target
+  end subroutine kp2
+end program fuzz_prog
+! site:
+! title: ftn: default(none) on a parallel construct in one internal subroutine makes a variable of another subroutine's target
+! + region an error (ftn-1510)
+! control: ../vendor/checks/src/other/control/s1-91-cce21-control.f90 default(none) removed from the empty parallel construct of
+! + kp1 (the
+! + ftn-1510
+! + for HF2 goes away; CCE then stops at the masked construct, documented as unsupported in offload regions)
+! end site

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

@@ -0,0 +1,59 @@
+! Minimized by compliance.fuzz_min from fuzz seed 9443 (fuzz-3).
+! toolchain: afar (-O2, HSA_XNACK=1, OMP_TARGET_OFFLOAD=mandatory)
+! failure: run_error (crash)
+! message: 'present' map type modifier
+! expected: runs to completion (the host run does)
+! observed: device: fail crash: SIGABRT; host reference (cce21) 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.
+! also fails on: cce19
+! Finding: AFAR aborts at HSA_XNACK=1 (SIGABRT, "Call to
+! getTargetPointer returned null pointer ('present' map type modifier)")
+! at an empty target construct with map(close, present, to: xk1), where
+! the enclosing target data construct maps xk1 (an integer(1) array); at
+! HSA_XNACK=0 AFAR runs it. CCE 19 also ends with exit status 1 in both
+! modes; CCE 20 and 21 run it.
+! Legal OpenMP 5.2: the target data construct makes xk1 present, so the
+! present modifier is satisfied (5.2 §5.8.3); close is a hint.
+! Observed (tuolumne, MI300A, -O2, 2026-10-23,
+! results/t28_probe/rt/9443-afar.f90.*.json): AFAR SIGABRT at HSA_XNACK=1,
+! "RESULT checksum=0" at HSA_XNACK=0; CCE 19 exit status 1 (both modes);
+! CCE 20, 21 "RESULT checksum=0". Reduced from s1 seed 9443 by
+! tools/campaigns/fuzz.py minimize-one (146 -> 82 lines). The present-modifier aborts
+! are AFAR's largest unified-only group in the copy-mode comparison.
+! Related: ../afar-xnack1-present-not-enforced.f90 (AFAR at HSA_XNACK=1
+! does not enforce present for an absent item: the opposite symptom of the
+! same unified-memory present handling).
+! Shorter form (fix; written by hand from
+! the 82-line reduction, which git history keeps): an integer(1) array
+! alone in target data map(to: xk1) and an empty target with
+! map(close, present, to: xk1) (data/evidence/dataenv_probe/short/c9443_a.f90).
+! Observed (tuolumne, MI300A, -O2, 2026-10-23, results/t28_probe/short/
+! c9443_a.f90.*.json): AFAR SIGABRT at HSA_XNACK=1, "RESULT check=pass" at
+! HSA_XNACK=0; CCE 19, 20, 21 pass in both modes (CCE 19's exit status 1
+! needs the longer form). Without close (c9443_b) AFAR passes: the close
+! modifier is the trigger. Expected: "RESULT check=pass".
+! Known defect: this is the AFAR close + present abort at
+! HSA_XNACK=1 of fuzz/158-afar.f90 and fuzz/1131-afar.f90 (there after
+! target enter data, here inside target data); not a new finding.
+program p
+  implicit none
+  integer, parameter :: n = 100
+  integer(1) :: xk1(n)
+  integer :: i
+  do i = 1, n
+    xk1(i) = int(mod(i * 17 + 16, 127), 1)
+  end do
+  !$omp target data map(to: xk1)
+    !$omp target map(close, present, to: xk1)
+    !$omp end target
+  !$omp end target data
+  print '(a)', 'RESULT check=pass'
+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-9443-afar-control.f90 map(present, to: xk1) without the close modifier
+! end site

offload/_root/data/findings/fuzz/s1-9914-cce19.f90

@@ -0,0 +1,78 @@
+! Finding: CCE 19 does not finish compiling this program (killed
+! after 300 s; the campaign's limit was 600 s), while CCE 20, CCE 21 and
+! AFAR compile it in seconds. The kernels: target constructs with
+! map(always, tofrom:) of a structure component and thread_limit, and a
+! target with a depend(out: go2(:)) on a declare target module array, in a
+! bundle with a default declare mapper and a submodule.
+!
+! A compile that does not finish is the compiler's defect whatever the
+! program (RUL-COMPILE-TIME); the program passed the fuzz legality checks
+! (offload.engine.rules, gfortran -std=f2008, AFAR flang's front end).
+!
+! Observed (tuolumne, -O2, 2026-10-23, results/t28_probe/hangv.log): CCE
+! 19.0.0 compile timeout; CCE 20.0.2, 21.0.3 and AFAR compile. Fuzz
+! campaign s1: the CCE 19 compile timeouts (93 cells in s1 and s1x0; every
+! one of those programs has target nowait with depend). Representative s1
+! seed 9914, reduced by deleting while the CCE 19 compile still ran after
+! 60 s (data/evidence/dataenv_probe/min_hang.py; 191 -> 99 lines).
+!
+! Fix: reduced further by line, clause and
+! list-item deletion while the CCE 19 compile still ran after 90 s
+! (data/evidence/dataenv_probe/min_ice.py with the compile-timeout oracle, 83 -> 34
+! lines, results/t28_probe/short/; each kept candidate timed out). What
+! remains: an empty target with thread_limit(1), an empty target with
+! depend(out: go2(:)) on a declare target module array, and a module
+! procedure in a submodule; CCE 20 compiles it in 5 s, CCE 21 in 10 s,
+! AFAR in 2 s. (The reduction's empty fuzz_ext.f90, a translation unit of
+! its own, is left out here.)
+!
+! ftn -fopenmp -O2 (a bundle: !@file marks start the files)
+!@file fuzz_dmod.f90
+module fuzz_dmod
+  implicit none
+  integer, parameter :: nm = 48
+  integer :: go2(nm)
+  !$omp declare target to(go2)
+end module fuzz_dmod
+!@file fuzz_smod.f90
+module fuzz_smod
+  implicit none
+  interface
+    module integer function gs1(x)
+      integer, intent(in) :: x
+    end function gs1
+  end interface
+end module fuzz_smod
+!@file fuzz_ssub.f90
+submodule (fuzz_smod) fuzz_ssub
+  implicit none
+contains
+  module integer function gs1(x)
+    integer, intent(in) :: x
+  end function gs1
+end submodule fuzz_ssub
+!@file fuzz_prog.f90
+program fuzz_prog
+  use fuzz_dmod
+  implicit none
+  !$omp target thread_limit(1)
+  !$omp end target
+  !$omp target depend(out: go2(:))
+  !$omp end target
+end program fuzz_prog
+! spec (requirement): a target construct accepts a depend clause (with an array section as list item) that is associated with
+!   the target task, and a thread_limit clause that bounds the threads of the contention group; the specification says nothing
+!   about compile time, so the requirement that these constructs are compiled at all is only implied.
+! "The target construct generates a target task. The generated task region encloses the target region. If a depend clause is
+!   present, it is associated with the target task. The device clause determines the device on which the target region executes.
+!   If the nowait clause is present," (5.2 §13.8 p.284 l.14-16)
+! "If the thread_limit clause is specified, the number of threads will be less than or equal to threadlim. Otherwise, if the"
+!   (5.2 §13.3 p.277 l.19-20)
+! spec (this program): an empty target with thread_limit(1) and an empty target with depend(out: go2(:)) on a declare target
+!   module array are legal constructs; CCE 19 does not finish compiling the program (killed after 300 s), CCE 20, CCE 21 and AFAR
+!   compile it in seconds.
+! site:
+! title: ftn 19 does not finish compiling target regions with map(always, tofrom:) of a structure component and a depend on a
+! + declare target array
+! control: ../vendor/checks/src/other/control/s1-9914-cce19-control.f90 thread_limit(1) removed from the first target
+! end site

offload/_root/data/findings/gcc/controls/gcc-acc-c-detach-control.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <openacc.h>
+
+enum { n = 64 };
+struct holder {
+  int *v;
+};
+
+int main(void) {
+  int b[n];
+  int host_flag = 1, sum = 0;
+  struct holder h;
+  h.v = malloc(n * sizeof(int));
+  for (int i = 0; i < n; i++) {
+    h.v[i] = 1;
+    b[i] = 0;
+  }
+  #pragma acc enter data copyin(h)
+  #pragma acc enter data copyin(h.v[0:n])
+  #pragma acc parallel loop copyout(b) copy(host_flag) present(h)
+  for (int i = 0; i < n; i++) {
+    if (i == 0) host_flag = acc_on_device(acc_device_host) ? 1 : 0;
+    b[i] = i + 1 + h.v[i];
+  }
+  #pragma acc exit data delete(h.v[0:n])
+  #pragma acc exit data delete(h)
+  for (int i = 0; i < n; i++)
+    sum += b[i];
+  free(h.v);
+  printf("sum= %d\n", sum);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, sum == 2144 ? "pass" : "fail");
+  return 0;
+}

offload/_root/data/findings/gcc/controls/gcc-acc-detach-control.f90

@@ -0,0 +1,26 @@
+program delete_only
+  use openacc, only: acc_device_host, acc_on_device
+  implicit none
+  integer, parameter :: n = 64
+  type :: holder
+    integer, allocatable :: v(:)
+  end type holder
+  type(holder) :: h
+  integer :: b(n)
+  integer :: i, host_flag
+  allocate(h%v(n))
+  h%v = 1
+  b = 0
+  host_flag = 1
+  !$acc enter data copyin(h)
+  !$acc enter data copyin(h%v)
+  !$acc parallel loop copyout(b) copy(host_flag) present(h)
+  do i = 1, n
+    if (i == 1) host_flag = merge(1, 0, acc_on_device(acc_device_host))
+    b(i) = i + h%v(i)
+  end do
+  !$acc exit data delete(h%v)
+  !$acc exit data delete(h)
+  print '(a,i0)', 'sum= ', sum(b)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', sum(b) == 2144)
+end program delete_only

offload/_root/data/findings/gcc/controls/gcc-defaultmap-to-pointer-control.f90

@@ -0,0 +1,31 @@
+program map_to_pointer
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer, pointer :: wp(:)
+  integer :: b(n), zc(1)
+  integer :: i, host_flag, changed
+  logical :: shared_mem
+  allocate(wp(n))
+  wp = 0
+  b = 0
+  host_flag = 1
+  zc = 0
+  ! separate memory? (a write to a map(to:) array is visible on the host only when storage is shared)
+  !$omp target map(to: zc)
+    zc(1) = 1
+  !$omp end target
+  shared_mem = zc(1) == 1
+  !$omp target map(from: b) map(tofrom: host_flag) map(to: wp)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    do i = 1, n
+      wp(i) = 2*i
+      b(i) = wp(i) + 1
+    end do
+  !$omp end target
+  changed = count(wp /= 0)
+  print '(a,i0,a,i0,a,l1)', 'b(n)= ', b(n), ' host wp changed: ', changed, ' shared_mem= ', shared_mem
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', &
+    merge('pass', 'fail', b(n) == 2*n + 1 .and. (shared_mem .or. changed == 0))
+  deallocate(wp)
+end program map_to_pointer