offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/cce-acc-routine-bind-module-ice.f90

@@ -0,0 +1,35 @@
+! OpenACC 3.4 §2.15.1 (routine bind): host_val is called on the device under
+! the name dev_val. Legal. Expected output: 3 5 7 9 11 13 15 17
+! (dev_val(x) = 2*x + 1). Compile: ftn -h acc -O2.
+module m
+  implicit none
+contains
+  integer function dev_val(x)
+    !$acc routine seq
+    integer, intent(in) :: x
+    dev_val = 2*x + 1
+  end function dev_val
+  integer function host_val(x)
+    !$acc routine seq bind(dev_val)
+    integer, intent(in) :: x
+    host_val = -x
+  end function host_val
+end module m
+
+program t
+  use m
+  implicit none
+  integer :: b(8), i
+  !$acc parallel loop copyout(b)
+  do i = 1, 8
+    b(i) = host_val(i)
+  end do
+  print *, b
+end program t
+! site:
+! title: ftn -h acc: internal compiler error "Object DEV_VAL is host associated to itself" for routine bind between two module
+! + procedures
+! control: ../vendor/checks/src/cce/control/cce-acc-routine-bind-module-ice-control.f90 the two functions as external procedures
+! + instead of
+! + module procedures
+! end site

offload/_root/data/findings/cce-acc-self-condition-ignored.f90

@@ -0,0 +1,17 @@
+! OpenACC 3.4 §2.5.7 (self clause): "When the condition evaluates to true,
+! the region will execute on the local device." Legal. Expected output:
+! on_host = T. Compile: ftn -h acc -O2.
+program t
+  use openacc
+  implicit none
+  logical :: on_host, use_host
+  use_host = .true.
+  on_host = .false.
+  !$acc serial self(use_host) copy(on_host)
+  on_host = acc_on_device(acc_device_host)
+  !$acc end serial
+  print *, 'on_host =', on_host
+end program t
+! site:
+! disposition: out-of-scope out of scope (maintainer ruling 2026-10-21): the construct of interest runs on the host
+! end site

offload/_root/data/findings/cce-c-dist-schedule-segv.c

@@ -0,0 +1,34 @@
+/* Finding (C): dist_schedule(static) without a chunk size on a
+   combined target teams distribute parallel for crashes on CCE.
+
+   Legal OpenMP 5.2 C (5.2 §11.6.1: dist_schedule(static) divides the
+   iterations into chunks of about equal size, one per team).
+
+   Expected: "64 of 64".
+   Observed at HSA_XNACK=1, -O2: CCE craycc 19.0.0, 20.0.2 and 21.0.3:
+   the program dies with SIGSEGV (also without OMP_TARGET_OFFLOAD=
+   mandatory; CCE 19 also at -O0). At HSA_XNACK=0 (copy mode) CCE 19
+   prints "64 of 64". Without the dist_schedule clause, or with
+   dist_schedule(static, 16), it prints "64 of 64" at HSA_XNACK=1. AFAR amdclang:
+   "64 of 64". CCE ftn runs the Fortran form (omp52-clause-dist_schedule)
+   correctly.
+
+   craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942
+          -fopenmp-version=52 -O2 */
+#include <stdio.h>
+int main(void) {
+  int b[64];
+  for (int i = 0; i < 64; i++) b[i] = 0;
+  #pragma omp target teams distribute parallel for map(from: b) \
+      num_teams(4) dist_schedule(static)
+  for (int i = 0; i < 64; i++) b[i] = i + 1;
+  int n = 0;
+  for (int i = 0; i < 64; i++) n += b[i] == i + 1;
+  printf("%d of 64\n", n);
+  return 0;
+}
+// site:
+// title: craycc: dist_schedule(static) on target teams distribute parallel for crashes (SIGSEGV) at HSA_XNACK=1
+// control: ../vendor/checks/src/cce/control/cce-c-dist-schedule-segv-control.c dist_schedule(static) removed
+// end site

offload/_root/data/findings/cce-c-map-delete-refcount.c

@@ -0,0 +1,47 @@
+// (copy mode for the whole catalog): CCE craycc keeps an array
+// present after map(delete: a) on target exit data when its reference
+// count is two.
+// a is entered twice (reference count 2), b once; target exit data
+// map(from: b) map(delete: a) sets a's reference count to zero and
+// removes it, and decrements b's to zero (5.2 §5.8.3 p.154: "If the
+// map-type is delete and the reference count of the corresponding
+// storage block is finite then the reference count is set to zero";
+// "If the reference count ... is zero, all storage ... is removed").
+// Expected: bad= 0 a_present= 0 b_present= 0
+// Observed (tuolumne, MI300A, 2026-10-22, 3 runs each, -O2,
+// OMP_TARGET_OFFLOAD=mandatory):
+// - CCE craycc 19.0.0, 20.0.2, 21.0.3: bad= 0 a_present= 1 b_present= 0,
+//   at HSA_XNACK 0 and 1 (delete acts like release).
+// - AFAR amdclang 24.0.0git: expected output in both modes.
+// The Fortran form passes on CCE (the catalog's Fortran map.delete
+// programs). The catalog's C map.delete programs (5.2, 6.0) check the
+// presence only in copy mode (copy_mode_only evidence: under unified
+// memory the presence checks are skipped), so CCE reads correct at
+// HSA_XNACK=1 and wrong at HSA_XNACK=0; with its presence checks run at
+// HSA_XNACK=1 (tools/campaigns/presence_x1.py) it fails there too. Not a copy-mode
+// failure: the class is x1_oracle_blind.
+// CCE: craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+//      -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942 -fopenmp-version=52 -O2
+//      (module load cce/<v> craype-accel-amd-gfx942 rocm)
+// Run:  OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+#include <stdio.h>
+#include <omp.h>
+enum { n = 64 };
+int main(void) {
+  int a[n], b[n], d = omp_get_default_device();
+  for (int i = 0; i < n; i++) { a[i] = i; b[i] = 0; }
+  #pragma omp target enter data map(to: a) map(alloc: b)
+  #pragma omp target enter data map(to: a)
+  #pragma omp target map(alloc: a, b)
+  for (int i = 0; i < n; i++) b[i] = 2 * a[i] + 1;
+  #pragma omp target exit data map(from: b) map(delete: a)
+  int bad = 0;
+  for (int i = 0; i < n; i++) bad += b[i] != 2 * i + 1;
+  printf("bad= %d a_present= %d b_present= %d\n", bad,
+         omp_target_is_present(a, d), omp_target_is_present(b, d));
+  return 0;
+}
+// site:
+// title: craycc: map(delete:) on target exit data acts as release for an array entered twice (still present)
+// control: ../vendor/checks/src/cce/control/cce-c-map-delete-refcount-control.c a entered once (reference count 1) instead of twice
+// end site

offload/_root/data/findings/cce-c-map-present-assert.c

@@ -0,0 +1,45 @@
+/* Finding (C): every map with the present modifier (and with the
+   close modifier) aborts in CCE's offload runtime.
+
+   Legal OpenMP 5.2 C. a is mapped by the enclosing target data, so
+   map(present, to: a) finds it present (5.2 §5.8.3: the present modifier
+   requires the item to be present, which it is) and the program prints
+   ok=1.
+
+   Observed (HSA_XNACK 0 and 1): CCE craycc 19.0.0, 20.0.2, 21.0.3 abort:
+     libcrayacc/acc_clang_wrapper.c:761: void
+     TransferList::validate_clang_flags(int64_t): Assertion
+     `clang_flags == 0' failed.
+   (line 1009 in CCE 20 and 21). The same assertion ends the program
+   with map(close, to: a) in place of map(present, to: a) (CCE 19, and
+   omp52/60-c-clause-map-close on CCE 19, 20, 21 in the matrix). The C
+   negative probe omp52-c-clause-map-present therefore ends in this
+   assertion instead of
+   the present-table message CCE prints for Fortran (CRAY_ACC_ERROR -
+   Variable not found in present table); AFAR amdclang prints ok=1 here and
+   libomptarget's present message for the probe (HSA_XNACK=0).
+
+   craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942
+          -fopenmp-version=52 -O2 */
+#include <stdio.h>
+#include <omp.h>
+int main(void) {
+  int a[64], b[64];
+  for (int i = 0; i < 64; i++) { a[i] = i; b[i] = 0; }
+  #pragma omp target data map(to: a)
+  {
+    #pragma omp target map(present, to: a) map(from: b)
+    {
+      for (int i = 0; i < 64; i++) b[i] = 2 * a[i];
+    }
+  }
+  int ok = 1;
+  for (int i = 0; i < 64; i++) ok = ok && b[i] == 2 * i;
+  printf("ok=%d\n", ok);
+  return 0;
+}
+// site:
+// title: craycc: every map with the present (or close) modifier aborts in the runtime: Assertion `clang_flags == 0' failed
+// control: ../vendor/checks/src/cce/control/cce-c-map-present-assert-control.c map(to: a) instead of map(present, to: a)
+// end site

offload/_root/data/findings/cce-c-openmp45-device-link.c

@@ -0,0 +1,34 @@
+/* Finding (C): with -fopenmp-version=45 CCE cannot link
+   omp_is_initial_device called in a target region.
+
+   Legal OpenMP 4.5 C (4.5 §3.2.34: omp_is_initial_device; runtime
+   library routines may be called in target regions).
+
+   Expected: "on_host=0".
+   Observed: CCE craycc 19.0.0, 20.0.2 and 21.0.3 with
+   -fopenmp-version=45 fail to link:
+     lld: error: undefined symbol: omp_is_initial_device
+     >>> referenced by ...-cce-openmp__llc.amdgpu:
+         (omp_is_initial_device_cce$omp_redun_clone)
+   With no version flag (default 5.1; CCE 19 also at 50 and 52) it
+   links and prints "on_host=0". The first omp_vv C baseline (each test
+   at the version of its spec directory) lost 115 of 315 tests on CCE to
+   this; the baseline now compiles 4.5-5.1 tests with the default.
+
+   craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942
+          -fopenmp-version=45 -O2 */
+#include <stdio.h>
+#include <omp.h>
+int main(void) {
+  int on_host = 1;
+  #pragma omp target map(tofrom: on_host)
+  on_host = omp_is_initial_device();
+  printf("on_host=%d\n", on_host);
+  return 0;
+}
+// site:
+// title: craycc -fopenmp-version=45: omp_is_initial_device called in a target region is an undefined symbol at the device link
+// control: ../vendor/checks/src/cce/control/cce-c-openmp45-device-link-control.c built without -fopenmp-version=45 (the default,
+// + 5.1)
+// end site

offload/_root/data/findings/cce-c-parallel-for-in-target.c

@@ -0,0 +1,73 @@
+/* Finding (C): a parallel for nested in a target region loses
+   iterations with schedule(static) and drops the final values of
+   lastprivate and linear list items on CCE.
+
+   Legal OpenMP 5.2 C. Inside the target region each parallel for must
+   run all 64 iterations (5.2 §11.5: every iteration is executed once,
+   whatever the schedule); lastprivate(t) gives t the value of the
+   sequentially last iteration (5.2 §5.4.5) and linear(x: 1) gives x its
+   value after the last iteration (5.2 §5.4.6), and the map(tofrom:)
+   returns both to the host.
+
+   Expected: "static 64 of 64; lastprivate t=63; linear 64 of 64, x=64".
+   Observed (-O2, HSA_XNACK=1; CCE 19 also at HSA_XNACK=0 and at -O0):
+   CCE craycc 19.0.0, 20.0.2 and 21.0.3 print "static 1 of 64; lastprivate t=-1; linear 64 of 64,
+   x=0" (the region has one thread; without schedule(static) all 64
+   iterations run, with schedule(static, 4) too). AFAR amdclang prints
+   the expected line, and CCE ftn runs the Fortran forms correctly
+   (omp52-clause-schedule-static, -lastprivate, -linear, -collapse).
+   In the matrix this makes the C collapse, lastprivate, linear and
+   schedule programs wrong_answer on CCE.
+
+   Probe (data/evidence/triage_probe/pfor_*.c, results/t27b/probes.jsonl,
+   tuolumne, both memory modes, 3 runs each): schedule(dynamic) loses
+   iterations too on CCE 19, 20 and 21 (b computed wrong, bad > 0), with or
+   without default(none) shared(a, b); the same parallel for without a
+   schedule clause (with or without default(none)) is correct; AFAR is
+   correct in every form. So schedule(static) without a chunk size,
+   schedule(dynamic) and the catalog's auto, guided, runtime, monotonic and
+   simd forms trigger it, as does lastprivate; schedule(static, 4) (above)
+   does not, so not every schedule clause does.
+
+   : three defects in one program (schedule(static)
+   loses iterations; lastprivate and linear lose the final value); the
+   control above covers only the first. The HPE packet splits them (cases
+   cce-c-parallel-for-in-target-static, -lastprivate, -linear, each with its
+   own control); a linear item's final value is lost with num_threads(1) too:
+   the linear case's former control (num_threads(1) added, now dropped from
+   the case) prints x=0 on CCE 19, 20, 21.0.3 and 21.0.4 in both modes
+   (data/vendor/checks/results-compact), so it does not isolate the defect
+   and is not listed as a control below.
+
+   craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+          -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942
+          -fopenmp-version=52 -O2 */
+#include <stdio.h>
+int main(void) {
+  int b[64], c[64], d[64], t = -1, x = 0;
+  for (int i = 0; i < 64; i++) { b[i] = 0; c[i] = 0; d[i] = -1; }
+  #pragma omp target map(from: b, c, d) map(tofrom: t, x)
+  {
+    #pragma omp parallel for schedule(static)
+    for (int i = 0; i < 64; i++) b[i] = i + 1;
+    #pragma omp parallel for lastprivate(t)
+    for (int i = 0; i < 64; i++) { c[i] = i + 1; t = i; }
+    #pragma omp parallel for linear(x: 1)
+    for (int i = 0; i < 64; i++) { d[i] = x; x++; }
+  }
+  int nb = 0, nd = 0;
+  for (int i = 0; i < 64; i++) { nb += b[i] == i + 1; nd += d[i] == i; }
+  printf("static %d of 64; lastprivate t=%d; linear %d of 64, x=%d\n",
+         nb, t, nd, x);
+  return 0;
+}
+// site:
+// title: craycc: parallel for schedule(static) in a target region runs 1 of 64 iterations
+// control: ../vendor/checks/src/cce/control/cce-c-parallel-for-in-target-control.c schedule(static) removed from the first
+// + parallel for
+// + (the
+// + first part of the output only)
+// control: ../vendor/checks/src/cce/control/cce-c-parallel-for-in-target-static-control.c schedule(static) removed
+// control: ../vendor/checks/src/cce/control/cce-c-parallel-for-in-target-lastprivate-control.c reduction(max: t) instead of
+// + lastprivate(t)
+// end site

offload/_root/data/findings/cce-defaultmap-tofrom-explicit-map.f90

@@ -0,0 +1,92 @@
+! CCE 19 applies defaultmap(tofrom) to an array the
+! same target construct maps EXPLICITLY with map(alloc:) or map(to:): on
+! exit it copies the device values back to the host.
+! Spec: on exit from the region the original list item is updated only "if
+! the map-type is from or tofrom" (5.2 §5.8.3 p.154, exit step 1a); alloc
+! and to have no from transfer. "The defaultmap clause determines the
+! implicit data-mapping or data-sharing attribute of certain variables"
+! (5.2 §5.8.7 p.161), and "explicit data-environment attribute clauses on
+! target directives determine the attributes" of the variables they name
+! (5.2 §5.8.1 p.148), so defaultmap(tofrom) does not change a's map type.
+! Premise: the original and corresponding items do not share storage. The
+! spec allows shared storage (5.2 §5.8.3 p.153, "may share storage"), so
+! the evidence holds only where they are separate: run at HSA_XNACK=0 (on
+! MI300A copy mode, on MI250X a discrete GPU), and the control regions 1
+! and 3 (the same maps without defaultmap) must leave the host a unchanged
+! (64 of 64): separate storage in the same configuration without
+! defaultmap; for regions 2 and 4 separate storage is the premise.
+! Expected: every region prints "host a unchanged: 64".
+! Observed (2026-10-22, -O2, OMP_TARGET_OFFLOAD=mandatory, HSA_XNACK=0, two
+! runs each, the same every run; tioga30 MI250X gfx90a and tuolumne1047
+! MI300A gfx942):
+! - CCE 19.0.0: regions 1 and 3: 64; regions 2 and 4
+!   (with defaultmap(tofrom)), ran_on_host=0: 0 -- the device's writes
+!   reached the host a.
+! - CCE 20.0.2 and AFAR 24.0.0git: 64 in every region (correct).
+! - CCE 21.0.3 and 21.0.4 : regions 2 and 4 print
+!   ran_on_host=1, but that is the map(tofrom) host_flag, which CCE 21 does
+!   not copy back in a region with defaultmap (cce21-defaultmap-aggregate-
+!   flag.f90): the label `ran_on_host=` names no independent measurement,
+!   and the regions run on the device. At HSA_XNACK=0 CCE 21.0.3 and 21.0.4
+!   copy a back in regions 2 and 4 (host a unchanged: 0): this defect, fixed
+!   in 20.0.2, is back in 21 (data/vendor/hpe/cce21-defaultmap-aggregate-
+!   flag.md, variants: confirmed in the four environments on both releases).
+! Found by the gfx90a map-mutant audit (data/reports/map-mutant-audit-
+! gfx90a.md): the weaken_map and swap_to_from mutants of the defaultmap-
+! tofrom programs survive on CCE 19.
+! CCE:  ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-<gfx>
+!       rocm/<r>; module unload cray-mpich)
+! AFAR: amdflang -fopenmp --offload-arch=<gfx> -O2
+! Run:  OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable :: a(:)
+  integer :: i, k, host_flag
+  do k = 1, 4
+    allocate(a(n))
+    a = [(i, i = 1, n)]
+    host_flag = 1
+    select case (k)
+    case (1)
+      !$omp target map(alloc: a) map(tofrom: host_flag)
+        host_flag = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          a(i) = -i
+        end do
+      !$omp end target
+    case (2)
+      !$omp target map(alloc: a) map(tofrom: host_flag) defaultmap(tofrom)
+        host_flag = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          a(i) = -i
+        end do
+      !$omp end target
+    case (3)
+      !$omp target map(to: a) map(tofrom: host_flag)
+        host_flag = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          a(i) = -i
+        end do
+      !$omp end target
+    case (4)
+      !$omp target map(to: a) map(tofrom: host_flag) defaultmap(tofrom)
+        host_flag = merge(1, 0, omp_is_initial_device())
+        do i = 1, n
+          a(i) = -i
+        end do
+      !$omp end target
+    end select
+    print '(a,i0,a,i0,a,i0)', 'region ', k, ': ran_on_host=', host_flag, &
+      ' host a unchanged: ', count(a == [(i, i = 1, n)])
+    deallocate(a)
+  end do
+end program p
+! 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/cce-defaultmap-tofrom-explicit-map-control.f90 defaultmap(tofrom) removed from
+! + regions 2 and 4
+! same_as: cce21-defaultmap-aggregate-flag
+! end site

offload/_root/data/findings/cce-mapper-next-map-copy-back.f90

@@ -0,0 +1,48 @@
+! (copy mode for the whole catalog): CCE 19 and 20 lose the
+! copy-back of the map list item that FOLLOWS a map clause with a mapper
+! modifier, at HSA_XNACK=0 only (separate host and device memory).
+! s is mapped through the user-defined mapper mm (map(to: q%v)); the
+! final map type is to (5.2 §5.8.8 p.163, Table 5.3: mapper to, clause
+! tofrom -> to), so s%v keeps its host value 1 in copy mode. host_flag is
+! map(tofrom:) and is set to 0 on the device; it must come back (5.2 §5.8.3
+! p.151: "the map-type is replaced with a final map type ... according to
+! the rules of map-type decay" applies to the mapper's list item only).
+! Expected (copy mode): host_flag= 0  b1= 3  sv= 1
+! Observed (tuolumne, MI300A, 2026-10-22, 3 runs each, -O2,
+! OMP_TARGET_OFFLOAD=mandatory):
+! - CCE 19.0.0, 20.0.2 at HSA_XNACK=0: host_flag= 1  b1= 3  sv= 1 on every
+!   run: the region ran on the device (b came back, s%v was not copied
+!   back) but host_flag's copy-back is lost. With the host_flag clause
+!   BEFORE the mapper clause, host_flag= 0 (correct); without the mapper
+!   modifier correct. At HSA_XNACK=1 correct (host_flag= 0, sv= 7).
+! - CCE 21.0.3 and AFAR 24.0.0git: correct in both modes.
+! The catalog's map.mapper programs (5.0, 5.2) put host_flag after the
+! mapper clause, so CCE 19/20 report them as "fell back to host"
+! (ran_on_host=1) at HSA_XNACK=0.
+! AFAR: amdflang -fopenmp --offload-arch=gfx942 -O2
+! CCE:  ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm)
+! Run:  OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+program p
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  type :: dt
+    integer :: v
+  end type dt
+  !$omp declare mapper(mm: dt :: q) map(to: q%v)
+  integer :: host_flag, b(4)
+  type(dt) :: s
+  s%v = 1
+  host_flag = 1
+  b = 0
+  !$omp target map(from: b) map(mapper(mm), tofrom: s) map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    b = 2 + s%v
+    s%v = 7
+  !$omp end target
+  print *, 'host_flag=', host_flag, ' b1=', b(1), ' sv=', s%v
+end program p
+! site:
+! title: ftn in copy mode: the map list item after a map clause with a mapper modifier is not copied back
+! control: ../vendor/checks/src/cce/control/cce-mapper-next-map-copy-back-control.f90 the map(tofrom: host_flag) clause written
+! + before the mapper clause
+! end site

offload/_root/data/findings/cce-trim-merge-output-one-character.f90

@@ -0,0 +1,40 @@
+! scope: out of scope (host only: a Fortran output statement, no OpenMP; kept as a record)
+! # Record (lead 3): CCE ftn prints one character of trim(merge('pass', 'fail', ok))
+!
+! - compiler: CCE ftn 19.0.0, 20.0.2, 21.0.3 and 21.0.4, with and without -fopenmp (-h noomp), -O0
+!   and -O2 (Tuolumne)
+! - expected: every line ends in pass (A check=pass, B check=pass, C len= 4, D check=pass, E
+!   check=pass, F check=pass, G check=xpassy). merge('pass', 'fail', ok) is 'pass' when ok is
+!   true (both sources have length 4, as MERGE requires), and TRIM of it is 'pass' (the Fortran 2008
+!   standard's MERGE and TRIM).
+! - actual: A check=p and B check=p (the trimmed merge as an output item, list-directed or with a
+!   format, prints its first character); C, D, E, F, G are right: LEN of the same expression is 4,
+!   TRIM of a variable holding it, the untrimmed merge, a constant mask and the expression inside
+!   a concatenation all print pass.
+! - other family: AFAR amdflang prints pass on every line.
+! - found by: the data-environment pilot, whose first RESULT lines used
+!   trim(merge('pass', 'fail', ok)) ("A false start is not counted").
+! - legality: plain Fortran 2008 (no OpenMP); offload.engine.prerun.check's rules and AFAR flang front
+!   end accept it (data/evidence/lead_probe/logs/legality_new.jsonl); no compiler under test, gfortran or gcc
+!   is a legality witness.
+! - scope: a host base-language defect: outside the device-offload scope (see data/reports/rulings.md),
+!   so it is recorded here, not counted as an offload finding.
+! - evidence: data/evidence/lead_probe/leads/tm_host.f90, tm_target.f90 (the same in a program with a target
+!   region), data/evidence/lead_probe/logs/leads_tuolumne.jsonl and leads_tuolumne_noomp.txt
+program tm
+  implicit none
+  logical :: ok
+  character(len=4) :: c
+  ok = .true.
+  print *, 'A check=', trim(merge('pass', 'fail', ok))
+  print '(a,a)', 'B check=', trim(merge('pass', 'fail', ok))
+  print *, 'C len=', len(trim(merge('pass', 'fail', ok)))
+  c = merge('pass', 'fail', ok)
+  print *, 'D check=', trim(c)
+  print *, 'E check=', merge('pass', 'fail', ok)
+  print *, 'F check=', trim(merge('pass', 'fail', .true.))
+  print *, 'G check=', 'x'//trim(merge('pass', 'fail', ok))//'y'
+end program tm
+! site:
+! disposition: out-of-scope host only: a Fortran output statement with no offload construct
+! end site

offload/_root/data/findings/cce-uses-allocators-traits-omp50.f90

@@ -0,0 +1,28 @@
+! OpenMP 5.0 §2.12.5 p.170: uses_allocators(allocator[(allocator-traits-array)]).
+! The allocator handle is shared on a parallel do nested in the target
+! region (a different construct, so 5.0 §2.12.5 p.175 does not forbid it).
+! Expected: compiles and prints 2*i+1. The same program with the 5.2 form
+! uses_allocators(traits(my_traits): my_alloc) compiles on CCE 19/20/21.
+program p
+  use omp_lib
+  implicit none
+  integer, parameter :: n = 8
+  integer :: a(n), b(n), i, t
+  integer(omp_allocator_handle_kind) :: my_alloc
+  type(omp_alloctrait), parameter :: my_traits(1) = &
+    [omp_alloctrait(omp_atk_alignment, 64)]
+  a = [(i, i = 1, n)]
+  !$omp target map(to: a) map(from: b) uses_allocators(my_alloc(my_traits))
+  !$omp parallel do private(t) allocate(my_alloc: t) default(none) shared(a, b, my_alloc)
+  do i = 1, n
+    t = 2*a(i)
+    b(i) = t + 1
+  end do
+  !$omp end target
+  print *, b
+end program p
+! site:
+! title: ftn: OpenMP 5.0 form uses_allocators(my_alloc(my_traits)) rejected as a function reference (ftn-451)
+! control: ../vendor/checks/src/cce/control/cce-uses-allocators-traits-omp50-control.f90 the OpenMP 5.2 spelling
+! + uses_allocators(traits(my_traits): my_alloc)
+! end site

offload/_root/data/findings/cce19-acc-if-false-link.f90

@@ -0,0 +1,17 @@
+! OpenACC 3.4 §2.5.6 (if clause): with a false condition the local thread
+! executes the region. Legal. Expected output: on_host = T.
+! Compile: ftn -h acc -O2.
+program t
+  use openacc
+  implicit none
+  logical :: on_host, use_dev
+  use_dev = .false.
+  on_host = .false.
+  !$acc serial if(use_dev) copy(on_host)
+  on_host = acc_on_device(acc_device_host)
+  !$acc end serial
+  print *, 'on_host =', on_host
+end program t
+! site:
+! disposition: out-of-scope out of scope (maintainer ruling 2026-10-21): the region with if(.false.) runs on the host
+! end site