offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/cce19-c-reduction-63-scalars-one-wrong.c

@@ -0,0 +1,235 @@
+// (the reproduction gate's review queue, entry 72: the
+// stress program scalars-c-64, kernel k0012, reduced): CCE 19 craycc gives
+// one of 63 int64 sum reductions, and one of 64 (the two sizes above 62
+// tested), on target teams distribute parallel for a wrong value, silently.
+// With 62 or fewer every value is right. (Fix.)
+// Spec: each list item of the reduction clause gets the combination of its
+// private copies with its original value (OpenMP 5.2 §5.5.8 p.134), and on
+// a combined target construct a reduction list item is also map(tofrom)
+// (§17.2 p.341 l.10-13); neither OpenMP nor C sets a limit on the number of list
+// items. Each s_k starts at 100 + k and adds k in each of 4 iterations, so
+// it ends at 100 + 5k. Expected: "bad= 0".
+// Observed (Tuolumne MI300A, -O2, OMP_TARGET_OFFLOAD=mandatory, 2026-10-26;
+// data/evidence/gate_probe/logs/reduce.txt): CCE 19.0.0 at HSA_XNACK 0 and 1:
+// "bad= 1 first= 11 (value 620, expected 155)" in every run (the same
+// program with 63 scalars: s3 = 580 instead of 115); with 8, 16, ..., 56 and 57 to 62 scalars: bad= 0
+// (control, data/evidence/gate_probe/reduce/red_c_N.c); CCE 20.0.2 and 21.0.3: bad= 0.
+// Another family: nvc 25.11 and 26.9 (A100, separate memory): bad= 0 at 64
+// and at 63 (data/evidence/gate_probe/logs/wingtip5.log, wingtip6.log; those runs
+// used red_c_63.c and an earlier red_c_64.c whose printf lacked the
+// "(value ..., expected ...)" text: the kernel is identical). AFAR amdclang stops at
+// the same size: 62 scalars work, at 63 the kernel traps ("execution
+// interrupted by hardware trap instruction", SIGABRT; the stress program's
+// form prints "Too many arguments in kmp_invoke_microtask, aborting
+// execution" first): a failing run, where CCE 19 gives a wrong value
+// without any message.
+// CCE: cc -fopenmp -O2 (module load cce/19.0.0 craype-accel-amd-gfx942 rocm)
+// Run: OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+#include <stdio.h>
+#include <stdint.h>
+int main(void) {
+  int64_t s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63, s64;
+  s1 = 101;
+  s2 = 102;
+  s3 = 103;
+  s4 = 104;
+  s5 = 105;
+  s6 = 106;
+  s7 = 107;
+  s8 = 108;
+  s9 = 109;
+  s10 = 110;
+  s11 = 111;
+  s12 = 112;
+  s13 = 113;
+  s14 = 114;
+  s15 = 115;
+  s16 = 116;
+  s17 = 117;
+  s18 = 118;
+  s19 = 119;
+  s20 = 120;
+  s21 = 121;
+  s22 = 122;
+  s23 = 123;
+  s24 = 124;
+  s25 = 125;
+  s26 = 126;
+  s27 = 127;
+  s28 = 128;
+  s29 = 129;
+  s30 = 130;
+  s31 = 131;
+  s32 = 132;
+  s33 = 133;
+  s34 = 134;
+  s35 = 135;
+  s36 = 136;
+  s37 = 137;
+  s38 = 138;
+  s39 = 139;
+  s40 = 140;
+  s41 = 141;
+  s42 = 142;
+  s43 = 143;
+  s44 = 144;
+  s45 = 145;
+  s46 = 146;
+  s47 = 147;
+  s48 = 148;
+  s49 = 149;
+  s50 = 150;
+  s51 = 151;
+  s52 = 152;
+  s53 = 153;
+  s54 = 154;
+  s55 = 155;
+  s56 = 156;
+  s57 = 157;
+  s58 = 158;
+  s59 = 159;
+  s60 = 160;
+  s61 = 161;
+  s62 = 162;
+  s63 = 163;
+  s64 = 164;
+  #pragma omp target teams distribute parallel for reduction(+: s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24, s25, s26, s27, s28, s29, s30, s31, s32, s33, s34, s35, s36, s37, s38, s39, s40, s41, s42, s43, s44, s45, s46, s47, s48, s49, s50, s51, s52, s53, s54, s55, s56, s57, s58, s59, s60, s61, s62, s63, s64)
+  for (int ii = 0; ii < 4; ii++) {
+    s1 += 1;
+    s2 += 2;
+    s3 += 3;
+    s4 += 4;
+    s5 += 5;
+    s6 += 6;
+    s7 += 7;
+    s8 += 8;
+    s9 += 9;
+    s10 += 10;
+    s11 += 11;
+    s12 += 12;
+    s13 += 13;
+    s14 += 14;
+    s15 += 15;
+    s16 += 16;
+    s17 += 17;
+    s18 += 18;
+    s19 += 19;
+    s20 += 20;
+    s21 += 21;
+    s22 += 22;
+    s23 += 23;
+    s24 += 24;
+    s25 += 25;
+    s26 += 26;
+    s27 += 27;
+    s28 += 28;
+    s29 += 29;
+    s30 += 30;
+    s31 += 31;
+    s32 += 32;
+    s33 += 33;
+    s34 += 34;
+    s35 += 35;
+    s36 += 36;
+    s37 += 37;
+    s38 += 38;
+    s39 += 39;
+    s40 += 40;
+    s41 += 41;
+    s42 += 42;
+    s43 += 43;
+    s44 += 44;
+    s45 += 45;
+    s46 += 46;
+    s47 += 47;
+    s48 += 48;
+    s49 += 49;
+    s50 += 50;
+    s51 += 51;
+    s52 += 52;
+    s53 += 53;
+    s54 += 54;
+    s55 += 55;
+    s56 += 56;
+    s57 += 57;
+    s58 += 58;
+    s59 += 59;
+    s60 += 60;
+    s61 += 61;
+    s62 += 62;
+    s63 += 63;
+    s64 += 64;
+  }
+  int bad = 0, first = -1;
+  long fv = 0;
+  if (s1 != 105) { bad++; if (first < 0) { first = 1; fv = (long) s1; } }
+  if (s2 != 110) { bad++; if (first < 0) { first = 2; fv = (long) s2; } }
+  if (s3 != 115) { bad++; if (first < 0) { first = 3; fv = (long) s3; } }
+  if (s4 != 120) { bad++; if (first < 0) { first = 4; fv = (long) s4; } }
+  if (s5 != 125) { bad++; if (first < 0) { first = 5; fv = (long) s5; } }
+  if (s6 != 130) { bad++; if (first < 0) { first = 6; fv = (long) s6; } }
+  if (s7 != 135) { bad++; if (first < 0) { first = 7; fv = (long) s7; } }
+  if (s8 != 140) { bad++; if (first < 0) { first = 8; fv = (long) s8; } }
+  if (s9 != 145) { bad++; if (first < 0) { first = 9; fv = (long) s9; } }
+  if (s10 != 150) { bad++; if (first < 0) { first = 10; fv = (long) s10; } }
+  if (s11 != 155) { bad++; if (first < 0) { first = 11; fv = (long) s11; } }
+  if (s12 != 160) { bad++; if (first < 0) { first = 12; fv = (long) s12; } }
+  if (s13 != 165) { bad++; if (first < 0) { first = 13; fv = (long) s13; } }
+  if (s14 != 170) { bad++; if (first < 0) { first = 14; fv = (long) s14; } }
+  if (s15 != 175) { bad++; if (first < 0) { first = 15; fv = (long) s15; } }
+  if (s16 != 180) { bad++; if (first < 0) { first = 16; fv = (long) s16; } }
+  if (s17 != 185) { bad++; if (first < 0) { first = 17; fv = (long) s17; } }
+  if (s18 != 190) { bad++; if (first < 0) { first = 18; fv = (long) s18; } }
+  if (s19 != 195) { bad++; if (first < 0) { first = 19; fv = (long) s19; } }
+  if (s20 != 200) { bad++; if (first < 0) { first = 20; fv = (long) s20; } }
+  if (s21 != 205) { bad++; if (first < 0) { first = 21; fv = (long) s21; } }
+  if (s22 != 210) { bad++; if (first < 0) { first = 22; fv = (long) s22; } }
+  if (s23 != 215) { bad++; if (first < 0) { first = 23; fv = (long) s23; } }
+  if (s24 != 220) { bad++; if (first < 0) { first = 24; fv = (long) s24; } }
+  if (s25 != 225) { bad++; if (first < 0) { first = 25; fv = (long) s25; } }
+  if (s26 != 230) { bad++; if (first < 0) { first = 26; fv = (long) s26; } }
+  if (s27 != 235) { bad++; if (first < 0) { first = 27; fv = (long) s27; } }
+  if (s28 != 240) { bad++; if (first < 0) { first = 28; fv = (long) s28; } }
+  if (s29 != 245) { bad++; if (first < 0) { first = 29; fv = (long) s29; } }
+  if (s30 != 250) { bad++; if (first < 0) { first = 30; fv = (long) s30; } }
+  if (s31 != 255) { bad++; if (first < 0) { first = 31; fv = (long) s31; } }
+  if (s32 != 260) { bad++; if (first < 0) { first = 32; fv = (long) s32; } }
+  if (s33 != 265) { bad++; if (first < 0) { first = 33; fv = (long) s33; } }
+  if (s34 != 270) { bad++; if (first < 0) { first = 34; fv = (long) s34; } }
+  if (s35 != 275) { bad++; if (first < 0) { first = 35; fv = (long) s35; } }
+  if (s36 != 280) { bad++; if (first < 0) { first = 36; fv = (long) s36; } }
+  if (s37 != 285) { bad++; if (first < 0) { first = 37; fv = (long) s37; } }
+  if (s38 != 290) { bad++; if (first < 0) { first = 38; fv = (long) s38; } }
+  if (s39 != 295) { bad++; if (first < 0) { first = 39; fv = (long) s39; } }
+  if (s40 != 300) { bad++; if (first < 0) { first = 40; fv = (long) s40; } }
+  if (s41 != 305) { bad++; if (first < 0) { first = 41; fv = (long) s41; } }
+  if (s42 != 310) { bad++; if (first < 0) { first = 42; fv = (long) s42; } }
+  if (s43 != 315) { bad++; if (first < 0) { first = 43; fv = (long) s43; } }
+  if (s44 != 320) { bad++; if (first < 0) { first = 44; fv = (long) s44; } }
+  if (s45 != 325) { bad++; if (first < 0) { first = 45; fv = (long) s45; } }
+  if (s46 != 330) { bad++; if (first < 0) { first = 46; fv = (long) s46; } }
+  if (s47 != 335) { bad++; if (first < 0) { first = 47; fv = (long) s47; } }
+  if (s48 != 340) { bad++; if (first < 0) { first = 48; fv = (long) s48; } }
+  if (s49 != 345) { bad++; if (first < 0) { first = 49; fv = (long) s49; } }
+  if (s50 != 350) { bad++; if (first < 0) { first = 50; fv = (long) s50; } }
+  if (s51 != 355) { bad++; if (first < 0) { first = 51; fv = (long) s51; } }
+  if (s52 != 360) { bad++; if (first < 0) { first = 52; fv = (long) s52; } }
+  if (s53 != 365) { bad++; if (first < 0) { first = 53; fv = (long) s53; } }
+  if (s54 != 370) { bad++; if (first < 0) { first = 54; fv = (long) s54; } }
+  if (s55 != 375) { bad++; if (first < 0) { first = 55; fv = (long) s55; } }
+  if (s56 != 380) { bad++; if (first < 0) { first = 56; fv = (long) s56; } }
+  if (s57 != 385) { bad++; if (first < 0) { first = 57; fv = (long) s57; } }
+  if (s58 != 390) { bad++; if (first < 0) { first = 58; fv = (long) s58; } }
+  if (s59 != 395) { bad++; if (first < 0) { first = 59; fv = (long) s59; } }
+  if (s60 != 400) { bad++; if (first < 0) { first = 60; fv = (long) s60; } }
+  if (s61 != 405) { bad++; if (first < 0) { first = 61; fv = (long) s61; } }
+  if (s62 != 410) { bad++; if (first < 0) { first = 62; fv = (long) s62; } }
+  if (s63 != 415) { bad++; if (first < 0) { first = 63; fv = (long) s63; } }
+  if (s64 != 420) { bad++; if (first < 0) { first = 64; fv = (long) s64; } }
+  printf("bad= %d first= %d (value %ld, expected %ld) s1= %ld s64= %ld\n", bad, first, fv,
+         first < 0 ? 0L : 100L + 5L * first, (long) s1, (long) s64);
+  return 0;
+}
+// site:
+// title: craycc 19: with 63 or more int64 sum reductions on target teams distribute parallel for, one is wrong
+// end site

offload/_root/data/findings/cce19-target-parallel-guarded-loop.f90

@@ -0,0 +1,35 @@
+program t
+  use omp_lib, only: omp_get_thread_num
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable :: a(:), b(:)
+  integer :: ref(n), i, nbad
+  allocate(a(n), b(n))
+  do i = 1, n
+    a(i) = i; b(i) = 0; ref(i) = 2*i + 1
+  end do
+  !$omp target parallel map(to: a) map(from: b) 
+    if (omp_get_thread_num() == 0) then
+      do i = 1, n
+        b(i) = 2*a(i) + 1
+      end do
+    end if
+  !$omp end target parallel
+  nbad = count(b /= ref)
+  print *, 'base_cond bad=', nbad
+end program
+! site:
+! title: ftn -fopenmp: a sequential DO loop executed by one thread of a target parallel region runs only some of its iterations
+! + (-O2)
+! control: ../vendor/checks/src/cce/control/cce19-target-parallel-guarded-loop-control.f90 compiled at -O0 instead of -O2 (-O0)
+! end site
+! spec (requirement): Every thread of the team created by a parallel construct executes the region, and each thread
+!   may follow a different path of statements.
+! "Each thread can execute a path of statements that is different from that of the other threads." (5.2 §10.1 p.223
+!   l.27-28)
+! spec (requirement): The thread with thread number zero is the primary thread and takes part in executing the region
+!   like every other thread.
+! "All threads in the new team, including the primary thread, execute the region." (5.2 §10.1 p.223 l.16-17)
+! spec (this program): Only thread 0 enters the guarded branch and runs the sequential DO loop of 64 iterations, so
+!   base-language semantics require all 64 elements of b to be written; the spec adds no rule that cuts a sequential
+!   loop short. At -O2 the compiler runs only some of the iterations.

offload/_root/data/findings/cce19-target-parallel-single-ice.f90

@@ -0,0 +1,38 @@
+program t
+  use omp_lib, only: omp_get_thread_num
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable :: a(:), b(:)
+  integer :: ref(n), i, nbad
+  allocate(a(n), b(n))
+  do i = 1, n
+    a(i) = i; b(i) = 0; ref(i) = 2*i + 1
+  end do
+  !$omp target parallel map(to: a) map(from: b) 
+    !$omp single
+      do i = 1, n
+        b(i) = 2*a(i) + 1
+      end do
+    !$omp end single
+  !$omp end target parallel
+  nbad = count(b /= ref)
+  print *, 'single bad=', nbad
+end program
+! site:
+! title: ftn/craycc: constructs documented as unsupported in offload regions (single, masked, task, ordered, scan) give internal
+! + compiler errors or device link failures instead of a diagnostic
+! control: ../vendor/checks/src/cce/control/cce19-target-parallel-single-ice-control.f90 the single construct replaced by a
+! + worksharing do
+! + construct
+! end site
+! spec (requirement): A single construct in a parallel region is executed by exactly one thread of the team, with an
+!   implicit barrier at its end.
+! "The single construct specifies that the associated structured block is executed by only one of the threads in the
+!   team" (5.2 §11.1 p.241 l.2-3)
+! spec (requirement): The implicit barrier at the end of a single region applies unless nowait is specified.
+! "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)
+! spec (this program): The program uses single inside target parallel without nowait. The nesting rules of OpenMP 5.2
+!   list no restriction against single in a target region, so the program is legal; the vendor documentation that
+!   lists single as unsupported in offload regions is a statement outside the spec, and the compiler gives an internal
+!   error or link failure instead of a diagnostic.

offload/_root/data/findings/cce21-alloc-2e32-sum-wrong.f90

@@ -0,0 +1,68 @@
+! CCE 21: a target teams distribute parallel do over 2**32 iterations does
+! not run its last 256-iteration block (retitled; the file keeps
+! its name). Found as a wrong sum when the loop fills an integer(8)
+! allocatable of 2**32 elements on the device and a second loop reduces it
+! (the reproduction gate's review queue, entries 86 and 75, the
+! stress program runtime.alloc-omp at 2**32, which is already this one
+! kernel). The reduction is right; the fill loop leaves the last 256
+! elements unwritten.
+! Spec: integer(8) indices and extents, so nothing overflows (the largest
+! product is 642 * 2**32); every iteration of the loop runs once (5.2 §11.6 p.254
+! distribute, §11.5 p.247 worksharing-loop); the array is mapped by target enter
+! data map(alloc:) (§13.6 p.280) and the sum is a reduction on target teams
+! distribute parallel do (§5.5.8 p.134), mapped tofrom (§17.2 p.341
+! l.10-13). 2**32 * 8 bytes = 32 GiB on the host and 32 GiB on the device
+! (MI300A: 128 GB).
+! Expected: "s= 2164663527981" (642 is invertible mod 1009, so each run of
+! 1009 consecutive i adds 0 + 1 + ... + 1008 = 508536).
+! Observed (Tuolumne MI300A, -O2, OMP_TARGET_OFFLOAD=mandatory, one run at a
+! time, 2026-10-26; data/evidence/gate_probe/logs/reduce.txt):
+! - CCE 21.0.3, HSA_XNACK 0 and 1: s= 2164663393401 in 4 of 4 runs, 134580
+!   short: exactly the sum of mod(i*642, 1009) over i = 2**32-255 .. 2**32.
+! - Localization (after the later runs;
+!   data/evidence/gate_probe/reduce/): the same device fill, then target update from
+!   and a check on the host (fill_check_32.f90): "wrong= 256 big(nn)= 0
+!   big(nn-256)= 814" at XNACK 0, and at XNACK 1 big(nn)= -1 (the host's
+!   initial value, never overwritten): the last 256 iterations of the fill
+!   loop did not run. The array filled on the host, mapped to, and reduced
+!   by the same reduction loop (hostfill_reduce_32.f90): s= 2164663527981
+!   (right), both modes.
+! - Controls on CCE 21: the same program at 2**31 elements (alloc_31.f90):
+!   s= 1082331768994 (right); the same 2**32 iterations as one reduction loop
+!   without the array (iter_32.f90): right (8 runs).
+! - CCE 19.0.0 (XNACK 0 and 1) and 20.0.2 (XNACK 0 and 1): a GPU memory
+!   access fault (SIGABRT) at 2**32 in every run; CCE 20 faults in the fill
+!   loop alone (fill_check_32.f90); at 2**31 neither finishes within 300 s.
+!   data/reports/fuzz-stress.md records CCE 19/20's fill-and-reduce shape as
+!   wrong from 2**22 elements under candidate 6; its cause is not shown here,
+!   so this finding claims CCE 21 only.
+! Another family: AFAR amdflang (XNACK 0 and 1) and nvfortran 25.11 and 26.9
+! (A100 80 GB, separate memory): s= 2164663527981
+! (data/evidence/gate_probe/logs/wingtip5.log).
+! CCE: ftn -fopenmp -O2 (module load cce/21.0.3 craype-accel-amd-gfx942 rocm)
+! Run: OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out (needs 64 GiB free)
+program p
+  implicit none
+  integer(8) :: i, nn, s
+  integer(8), allocatable :: big(:)
+  nn = 2_8**32
+  s = 0
+  allocate(big(nn))
+  !$omp target enter data map(alloc: big)
+  !$omp target teams distribute parallel do
+  do i = 1, nn
+    big(i) = mod(i * 642, 1009_8)
+  end do
+  !$omp end target teams distribute parallel do
+  !$omp target teams distribute parallel do reduction(+: s)
+  do i = 1, nn
+    s = s + big(i)
+  end do
+  !$omp end target teams distribute parallel do
+  !$omp target exit data map(delete: big)
+  deallocate(big)
+  print '(a,i0)', 's= ', s
+end program p
+! site:
+! title: ftn 21: target teams distribute parallel do over 2**32 iterations skips its last 256-iteration block
+! end site

offload/_root/data/findings/cce21-defaultmap-aggregate-flag.f90

@@ -0,0 +1,52 @@
+! CCE 21: with a defaultmap clause on a target construct, the scalar x named
+! in map(tofrom: x) is not copied back (a correction: the header
+! this file did not have).
+! Spec: x is explicitly mapped tofrom, which defaultmap does not change
+! ("The defaultmap clause determines the implicit data-mapping or
+! data-sharing attribute of certain variables that are referenced in a
+! target construct", 5.2 §5.8.7 p.161 l.14-16), and on exit the original is
+! updated "if the map-type is from or tofrom" (5.2 §5.8.3 p.154 l.2-5).
+! Expected: A 0, B 0, C 0 (x = 0 from omp_is_initial_device() on the device).
+! Observed: CCE 21.0.3 and 21.0.4: A 1, B 0, C 1, at HSA_XNACK 0 and 1, -O0
+! and -O2. The region runs on the device: CRAY_ACC_DEBUG shows the kernel,
+! and an array flag mapped from in the same region comes back 0 (vendor
+! case cce21-defaultmap-device-probe); what is lost is the copy-back of x.
+! Control: region B, the same construct without defaultmap: 0. CCE 19.0.0
+! and 20.0.2: all zeros. The catalog's defaultmap programs read their
+! ran_on_host flag through such a map(tofrom) scalar, so on CCE 21 they
+! read ran_on_host=1 although they ran on the device (decided as this wrong
+! answer: catalog/rulings.yaml RUL-MAPPED-FLAG-NOT-COPIED-BACK).
+! CCE: ftn -fopenmp -O2 (module load cce/21.0.4 craype-accel-amd-gfx942
+!      rocm/7.2.0; module unload cray-mpich)
+program h
+  use omp_lib
+  implicit none
+  integer :: x, i
+  integer, allocatable :: a(:)
+  allocate(a(8)); a=1
+  x=1
+  !$omp target map(tofrom:x) map(to:a) defaultmap(to: aggregate)
+  x = merge(1,0,omp_is_initial_device())
+  !$omp end target
+  print *, 'A', x
+  x=1
+  !$omp target map(tofrom:x) map(to:a)
+  x = merge(1,0,omp_is_initial_device())
+  !$omp end target
+  print *, 'B', x
+  x=1
+  !$omp target map(tofrom:x) map(to:a) defaultmap(to: aggregate)
+  x = merge(1,0,omp_is_initial_device())
+  do i=1,8
+    a(i)=2
+  end do
+  !$omp end target
+  print *, 'C', x
+end
+! site:
+! title: ftn: with a defaultmap clause on target, an explicitly mapped map(tofrom) scalar is not copied back, and with
+! + defaultmap(tofrom) an array in map(alloc) or map(to) is copied back
+! control: ../vendor/checks/src/cce/control/cce21-defaultmap-aggregate-flag-control.f90 defaultmap(to: aggregate) removed from
+! + regions A
+! + and C
+! end site

offload/_root/data/findings/cce21-in-reduction-assumed-shape-write-lost.f90

@@ -0,0 +1,61 @@
+! (reducing the reproduction gate's review queue entry
+! 48, fuzz x0-alloc:197, whose kernel 4 is this pattern): CCE 21 loses the
+! writes to an assumed-shape dummy array in a target region that has
+! in_reduction (in a taskgroup with task_reduction), inside the procedure
+! whose dummy it is. With explicit-shape dummies, or without the
+! task_reduction/in_reduction pair, the writes come back.
+! Spec: y is a mappable list item mapped tofrom (5.2 §5.8.3 p.150; the only
+! Fortran list-item restriction, p.156, is on assumed-size arrays), so its
+! values at the end of the region are assigned back to the original; the
+! in_reduction clause on target (§5.5.10 p.138) and task_reduction on
+! taskgroup (§5.5.9 p.137) do not change the mapping of other list items. r
+! is not updated in the region. Expected: "r= 3 y(16)= 32".
+! Observed (Tuolumne MI300A, -O2, OMP_TARGET_OFFLOAD=mandatory, 3 runs per
+! cell, 2026-10-26; data/evidence/gate_probe/logs/reduce.txt, ids r2/inred_noh*):
+! CCE 21.0.3 at HSA_XNACK 0 and 1: "r= 3 y(16)= 0" in every run.
+! One-change controls of this program (after the later
+! runs; data/evidence/gate_probe/reduce/): x(n), y(n) explicit-shape
+! (inred_noh_explicit.f90) and the taskgroup and in_reduction removed
+! (inred_noh_noinred.f90) each give "r= 3 y(16)= 32" in 6 of 6 runs on
+! CCE 21, XNACK 0 and 1. CCE 19.0.0 and 20.0.2: right (both crash on the
+! fuller fuzz kernel instead: data/reports/gate-queue.md, entry 48). The
+! fix-round-1 form, which also printed an unwritten scalar h, gave the same
+! (inred_host_noh.f90), and so did a form that writes and maps h
+! (inred_host.f90).
+! With r updated in the region (r = r + x(i)) CCE 21 does not link it
+! ("undefined symbol: _cray$mt_taskwait": cce21-in-reduction-taskwait-link.f90),
+! so this program leaves r alone.
+! Another family: AFAR amdflang: "r= 3 y(16)= 32" (XNACK 0 and 1). NVHPC
+! nvfortran 25.11 and 26.9 reject task_reduction ("Syntax error at or near
+! identifier task_reduction" on data/evidence/gate_probe/reduce/unh_k2.f90 and
+! unh_k4.f90, data/evidence/gate_probe/logs/wingtip5.log), so it is no witness.
+! CCE: ftn -fopenmp -O2 (module load cce/21.0.3 craype-accel-amd-gfx942 rocm)
+! Run: OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+program p
+  implicit none
+  integer, parameter :: n = 16
+  integer :: a(n), b(n), r, i
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+  end do
+  r = 3
+  call k(a, b)
+  print '(a,i0,a,i0)', 'r= ', r, ' y(16)= ', b(n)
+contains
+  subroutine k(x, y)
+    integer, intent(in) :: x(:)
+    integer, intent(inout) :: y(:)
+    integer :: i
+    !$omp taskgroup task_reduction(+: r)
+      !$omp target map(to: x) map(tofrom: y) in_reduction(+: r)
+        do i = 1, n
+          y(i) = 2 * x(i)
+        end do
+      !$omp end target
+    !$omp end taskgroup
+  end subroutine k
+end program p
+! site:
+! title: ftn 21: writes to an assumed-shape dummy in a target region with in_reduction are lost
+! end site

offload/_root/data/findings/cce21-in-reduction-taskwait-link.f90

@@ -0,0 +1,59 @@
+! Generated by compliance.gen (OpenMP 5.2, free-form Fortran). Do not edit.
+! id: omp52-clause-in_reduction-and
+! primary atom: omp.clause.in_reduction.and
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+program gen_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable, target :: a(:), b(:)
+  integer :: ref(n)
+  integer :: i, host_flag
+  logical :: ok
+  logical :: ls, lsref
+  allocate(a(n), b(n))
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 2*i + 1
+  end do
+  host_flag = 1
+  ls = .true.
+  lsref = .true.
+  do i = 1, n
+    lsref = lsref .and. (a(i) /= 17)
+  end do
+  !$omp taskgroup task_reduction(.and.: ls)
+    !$omp target map(to: a) map(from: b) map(tofrom: host_flag) in_reduction(.and.: ls)
+      host_flag = merge(1, 0, omp_is_initial_device())
+      do i = 1, n
+        b(i) = 2*a(i) + 1
+        ls = ls .and. (a(i) /= 17)
+      end do
+    !$omp end target
+  !$omp end taskgroup
+  ok = all(b == ref) .and. (ls .eqv. lsref)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+  deallocate(a, b)
+end program gen_prog
+! site:
+! title: ftn: in_reduction on a target construct fails to link (undefined _cray$mt_taskwait in the device code)
+! control: ../vendor/checks/src/cce/control/cce21-in-reduction-taskwait-link-control.f90 in_reduction(.and.: ls) on the target
+! + replaced by
+! + map(tofrom: ls), without the enclosing taskgroup
+! end site
+! spec (requirement): An in_reduction clause on a target construct makes the target task a participant in the task
+!   reduction defined by an enclosing taskgroup with a matching task_reduction clause.
+! "For the target construct, the target task becomes the participating task." (5.2 §5.5.10 p.138 l.21-22)
+! spec (requirement): The private copy of an in_reduction list item on a target construct is implicitly mapped into
+!   the device data environment and combined at the end of the task region.
+! "This private copy will be implicitly mapped into the device data environment of the target device, if the target
+!   device is not the parent device." (5.2 §5.5.10 p.138 l.23-24)
+! spec (this program): The target construct lists in_reduction(.and.: ls) inside a taskgroup with
+!   task_reduction(.and.: ls), which matches in operator and list item; the compiler fails to link the device code
+!   (undefined _cray$mt_taskwait) instead of performing the reduction.

offload/_root/data/findings/cce21-linear-modifier-default-none.f90

@@ -0,0 +1,59 @@
+! Finding: CCE 21 rejects the OpenMP 5.2 linear modifier syntax
+! under default(none) with a false data-sharing diagnostic.
+!
+! Legal OpenMP 5.2: linear(x: val, step(1)) on a worksharing-loop (5.2
+! §5.4.6 pp.117-120; val is the default for a non-reference variable).
+! linear is a data-sharing attribute clause, so x has an explicitly
+! determined data-sharing attribute and default(none) is satisfied (5.2
+! §5.4.1 p.109). At the start of iteration i, x = 3 + (i - 1); after the
+! loop x = n + 3, reading "The value corresponding to the sequentially last
+! logical iteration of the associated loops is assigned to the original list
+! item" (5.2 §5.4.6 p.118) as the list item's value at the end of that
+! iteration, as for lastprivate (the other reading, its value at the start,
+! gives n + 2; CCE 21's failure is a compile-time rejection either way).
+! Expected: "RESULT ran_on_host=0 check=pass".
+! Legality rests on the quoted spec text: cited gfortran 13.3.1
+! -fopenmp as an independent witness; gfortran/gcc -fopenmp are withdrawn
+! as offload legality witnesses (data/reports/rulings.md).
+!
+! Observed (tuolumne, MI300A, both memory modes, -O2, 2026-10-22,
+! data/evidence/triage_probe/linear_mod.f90 and linear_mod_nodn.f90,
+! results/t27b/probes.jsonl):
+! - CCE 21.0.3 (whose intro_openmp(7) lists "new linear clause syntax
+!   (Fortran only)" among its OpenMP 5.2 features): ftn-1510 "Variable "X"
+!   must have its data scope explicitly declared because DEFAULT(NONE) was
+!   specified". Without default(none) shared(a, b): internal compiler error
+!   "ACC - barrier/reset/protected last private not supported" (the class of
+!   fuzz/1391-cce20.f90).
+! - CCE 19.0.0, 20.0.2: ftn-113, VAL read as an undeclared variable (they do
+!   not claim the 5.2 syntax).
+! - AFAR amdflang 24.0.0git: crashes (ICE) in both forms.
+! The catalog's omp52/60-clause-linear-val programs are rejected on every
+! compiler because of these.
+!
+! ftn -fopenmp -O2
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), i, x, host_flag
+  a = [(i, i = 1, n)]
+  b = 0
+  x = 3
+  host_flag = 1
+  !$omp target map(to: a) map(from: b) map(tofrom: x, host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    !$omp parallel do default(none) shared(a, b) linear(x: val, step(1))
+    do i = 1, n
+      b(i) = 2*a(i) + 1 + (x - (i + 2))
+      x = x + 1
+    end do
+  !$omp end target
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', &
+    merge('pass', 'fail', all(b == 2*a + 1) .and. x == n + 3)
+end program p
+! site:
+! title: ftn: internal compiler error "ACC - barrier/reset/protected last private not supported" for linear and lastprivate on a
+! + loop in a target region
+! same_as: catalog/cce-linear-lastprivate-ice
+! end site

offload/_root/data/findings/clang-c-declare-target-to-omp52.c

@@ -0,0 +1,50 @@
+/* Finding (C): at -fopenmp-version=52 both clang C front ends
+   reject the deprecated but normative `to` clause of declare target.
+
+   Legal OpenMP 5.2 C. "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; also
+   Appendix B.1 p.625), and "deprecated"
+   is "the property that it is normative in the current specification but
+   is considered obsolescent and will be removed in the future" (5.2
+   §1.2.7 p.20); 6.0 removes it (the catalog's 6.0 programs use enter).
+   Expected: "RESULT ran_on_host=0 check=pass".
+
+   Observed (tuolumne, MI300A, HSA_XNACK=1, -O2, 2026-10-22,
+   data/evidence/triage_probe/dt_to.c, results/t27b/probes.jsonl): AFAR amdclang
+   24.0.0git and CCE craycc 19.0.0, 20.0.2, 21.0.3 at -fopenmp-version=52:
+   "error: unexpected 'to' clause, use 'enter' instead"; without the flag
+   (their default, OpenMP 5.1) all four compile and run it correctly. The
+   catalog's omp52-c-clause-device_type, -device_type-any, -device_type-
+   nohost programs were rejected on every compiler because of it; since
+   Those C ports use enter(f), so they measure
+   device_type.
+
+   Legality rests on the quoted spec text only: there is no independent
+   compiler witness (cited gcc 13.3.1 -fopenmp; gfortran/gcc -fopenmp
+   are withdrawn as offload legality witnesses, data/reports/rulings.md).
+
+   amdclang -fopenmp --offload-arch=gfx942 -fopenmp-version=52 -O2
+   craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942
+          -fopenmp-version=52 -O2 */
+#include <stdio.h>
+#include <omp.h>
+enum { n = 64 };
+int f(int x) { return 2 * x + 1; }
+#pragma omp declare target to(f) device_type(any)
+int main(void) {
+  int a[n], b[n], bad = 0, host_flag = 1;
+  for (int i = 0; i < n; i++) { a[i] = i + 1; b[i] = 0; }
+  #pragma omp target map(to: a) map(from: b) map(tofrom: host_flag)
+  {
+    host_flag = omp_is_initial_device() ? 1 : 0;
+    for (int i = 0; i < n; i++) b[i] = f(a[i]);
+  }
+  for (int i = 0; i < n; i++) bad += b[i] != 2 * (i + 1) + 1;
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, bad ? "fail" : "pass");
+  return 0;
+}
+// site:
+// title: amdclang -fopenmp-version=52: declare target to(f) rejected ("unexpected 'to' clause, use 'enter' instead")
+// control: ../vendor/checks/src/other/control/clang-c-declare-target-to-omp52-control.c enter(f) instead of to(f)
+// end site