offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/harvest/afar-flang-strided-target-update.f90

@@ -0,0 +1,96 @@
+! # Finding: AFAR amdflang ignores the stride of a Fortran array
+! # section in `target update`: from(a(1:7:2)) copies all of a
+!
+! - compilers: AFAR amdflang 24.0.0git (drop 24.3.0), -O2: MI300A gfx942
+!   (HSA_XNACK=0; gate below) and MI250X gfx90a (HSA_XNACK=0; one probe of
+!   three runs, not gated)
+! - expected: a:  11.0   2.0  13.0   4.0  15.0   6.0  17.0   8.0
+!   / strided bad= 0 contiguous bad= 0
+! - actual: a:  11.0  12.0  13.0  14.0  15.0  16.0  17.0  18.0
+!   / strided bad= 4 (every element of a, a(8) too, comes back)
+!   (results/harvest/probe/gate/afar-flang-strided.r*.jsonl; gfx90a:
+!   results/harvest/probe/f1f2.jsonl, strided_f.f90)
+! - gate (four environments on gfx942 X0, tools/campaigns/harvest_probe.py
+!   --gate-envs, offload.engine.gate.judge): the stored run (three repeats) and
+!   (a), (b), (d) on tuolumne1020, (c) on tuolumne1021: the same wrong
+!   answer in every run; confirmed.
+! - rule: "The list items may include array sections with stride
+!   expressions ... If a list item is an array or array section then it is
+!   treated as if it is replaced by each of its array elements in the
+!   clause" (OpenMP 5.2 §5.9 p.165 l.13-17); a(1:7:2) is a(1), a(3), a(5),
+!   a(7) (a subscript triplet, Fortran 2008 6.5.3.3.2).
+! - copy mode only: with storage shared between host and device
+!   (HSA_XNACK=1) every device write is visible, so elements outside the
+!   section may differ legitimately.
+! - same-compiler controls (correct): update from(b(1:4)) (contiguous);
+!   AFAR amdclang's C form from(a[0:4:2]) (harvest/cce-c-strided-target-update.c).
+! - other families: none runs it: CCE ftn 19.0.0, 20.0.2, 21.0.3 reject it
+!   ("ftn-1747: The stride specified for array "A" in the MAP clause must
+!   not be greater than 1", although its man page says "Non-contiguous
+!   updates are supported for normal array slice expressions that specify a
+!   lower bound, upper bound, and optional stride"); NVHPC nvfortran 25.11
+!   and 26.9 reject it (NVFORTRAN-S-0034 syntax error at the stride).
+! - legality: legal by the quoted spec text only (no independent compiler
+!   witness: AFAR is the compiler under test, and CCE and NVHPC reject the
+!   stride). offload.engine.rules with the race rule accepts it. 5.2 §5.9 allows
+!   strided array sections in motion clauses; the map clause's contiguity
+!   restriction (CCE's ftn-1747 speaks of "the MAP clause") does not apply
+!   to `target update`. CCE's rejection is the finding
+!   fuzz/s1-6888-cce21.f90 (ftn-1747); NVHPC's is a candidate defect. That
+!   finding calls AFAR correct on its strided `to`: its program checks the
+!   updated elements only, where an ignored stride would not show.
+! - found by: while reducing the CCE C strided-update failures of
+!   llvm-project offload/test/offloading/strided_update/ (no Fortran test
+!   there).
+! AFAR: amdflang -fopenmp --offload-arch=gfx942 -O2
+! Run:  OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+program strided_f
+  use omp_lib
+  implicit none
+  real(8) :: a(8), b(8)
+  integer :: i, bad_a, bad_b, on_host
+  do i = 1, 8
+    a(i) = i
+    b(i) = i
+  end do
+  on_host = 1
+  !$omp target data map(to: a, b)
+  !$omp target map(from: on_host)
+  if (omp_is_initial_device()) then
+    on_host = 1
+  else
+    on_host = 0
+  end if
+  do i = 1, 8
+    a(i) = a(i) + 10
+    b(i) = b(i) + 10
+  end do
+  !$omp end target
+  !$omp target update from(a(1:7:2))
+  !$omp target update from(b(1:4))
+  !$omp end target data
+  bad_a = 0
+  bad_b = 0
+  do i = 1, 8
+    if (mod(i, 2) == 1) then
+      if (a(i) /= i + 10) bad_a = bad_a + 1
+    else
+      if (a(i) /= i) bad_a = bad_a + 1
+    end if
+    if (i <= 4) then
+      if (b(i) /= i + 10) bad_b = bad_b + 1
+    else
+      if (b(i) /= i) bad_b = bad_b + 1
+    end if
+  end do
+  print '(a,8f6.1)', 'a:', a
+  print '(a,i0,a,i0)', 'strided bad= ', bad_a, ' contiguous bad= ', bad_b
+  if (bad_a == 0) then
+    print '(a,i0,a)', 'RESULT ran_on_host=', on_host, ' check=pass'
+  else
+    print '(a,i0,a)', 'RESULT ran_on_host=', on_host, ' check=fail'
+  end if
+end program strided_f
+! site:
+! title: amdflang: target update from a strided array section copies the whole array
+! end site

offload/_root/data/findings/harvest/cce-acc-declare-create-module-allocatable-xnack1-fault.f90

@@ -0,0 +1,58 @@
+! # Finding (known-issues harvest): CCE faults on a module allocatable in
+!   declare create at HSA_XNACK=1 (MI300A)
+!
+! - source: MFC's compiler-ticket list (PE-53844, "CCE >17 crashes on host_data use_device for
+!   module variables"), reconstructed as data/bench/harvest-known hk-008 (a declare create module
+!   allocatable, host_data use_device, a deviceptr routine); the fault is at the first compute
+!   construct, before host_data, so this file drops host_data
+!   (data/reports/harvest-known/v008-declare-create-alloc.f90)
+! - compilers: CCE 19.0.0, 20.0.2, 21.0.3, ftn -h acc -O2, MI300A at HSA_XNACK=1 (THP always)
+! - expected: bad = 0, RESULT ... check=pass. For an allocatable in declare create, "for an
+!   allocate statement for var ... memory will be allocated in both local memory as well as in the
+!   current device memory" on a non-shared memory device (OpenACC 3.4 §2.13.2 p.83 l.3053-3057); on
+!   a shared memory device the host memory is the device's; either way buf is present in the
+!   parallel loop and the update copies (or leaves) the values
+! - actual: CCE 19 and 20: "Memory access fault by GPU node-4 ... on address 0x6000. Reason: Write
+!   access to a read-only page." (SIGABRT); CCE 21: "hipStreamSynchronize returned
+!   hipErrorIllegalAddress ... from v008-declare-create-alloc.f90:19" (the parallel loop), exit 1
+! - control (same compiler): HSA_XNACK=0 passes; at HSA_XNACK=1 a local allocatable made present
+!   with enter data create passes (c008-local-enter-data.f90), and a fixed-size module array in
+!   declare create passes (c008-fixed-module.f90), both in data/reports/harvest-known/
+! - other families: NVHPC 25.11 and 26.9 (OpenACC; separate and managed memory) pass; AFAR has no
+!   OpenACC
+! - legality: the pre-run check (rules and the AFAR front end with -fopenacc) accepts it; present
+!   requires the data present, which declare create and the allocate statement provide
+! - also: hk-007 (MFC ticket OLCFHELP-19298 / HPECOE-71) and hk-013 (thornado commit 2253976852,
+!   "another CCE bug") hold a module allocatable in declare create too, and fail the same way on CCE
+!   19/20/21 at HSA_XNACK=1 only (19 and 20 fault, 21 hipErrorIllegalAddress; another node)
+! - evidence: results/harvest-known/main (hk-007, hk-008, hk-013, CCE 19/20/21 at HSA_XNACK=1),
+!   results/harvest-known/probes.tuolumne.jsonl, probes.wingtip.jsonl
+module v008_m
+  implicit none
+  real(8), allocatable :: buf(:)
+  !$acc declare create(buf)
+end module v008_m
+
+program v008
+  use openacc
+  use v008_m
+  implicit none
+  integer, parameter :: n = 4096
+  integer :: i, bad, hk_host
+  allocate(buf(n))
+  !$acc parallel loop present(buf)
+  do i = 1, n
+    buf(i) = real(i, 8)
+  end do
+  !$acc update host(buf)
+  bad = count(buf /= [(real(i, 8), i = 1, n)])
+  hk_host = 1
+  !$acc parallel num_gangs(1) copy(hk_host)
+  if (.not. acc_on_device(acc_device_host)) hk_host = 0
+  !$acc end parallel
+  print '(a,i0)', 'bad = ', bad
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', hk_host, ' check=', merge('pass', 'fail', bad == 0)
+end program v008
+! site:
+! title: ftn (OpenACC): a module allocatable in declare create faults at HSA_XNACK=1
+! end site

offload/_root/data/findings/harvest/cce-c-implicit-struct-map-partly-present.c

@@ -0,0 +1,100 @@
+// # Finding: CCE craycc stops with "overlaps present region but is
+// # not contained" when a target region implicitly maps a structure some of
+// # whose members a target data construct already mapped
+//
+// - compilers: CCE craycc 19.0.0, 20.0.2, 21.0.3, 21.0.4, -O2: this file on
+//   MI300A gfx942 (HSA_XNACK 0 and 1); the OpenMP Examples program
+//   target_struct_map.4 (Case 1 of which this file is) also on MI250X gfx90a.
+// - expected: 4 202 dev= 1 (s.p[0] = 0*2+4, s.p[99] = 99*2+4)
+// - actual: no output; the runtime stops at the target construct:
+//   "ACC: libcrayacc/acc_present.c:762 CRAY_ACC_ERROR - Host region (... to
+//   ...) overlaps present region (... to ... index 0) but is not contained
+//   for 's'", exit status 1, every run, both memory modes.
+// - rule: the target construct references s (the call saxpy(&s)), so s is
+//   treated as if it appeared in a map clause with map-type tofrom (5.2 §5.8.1
+//   p.149 l.4-5); s.a, s.b and s.p are already present as one storage block
+//   (list items with the same containing structure form "a single mappable
+//   storage block", 5.2 §5.8.3 p.152 l.28-31); and "If a single contiguous
+//   part of the original storage of a list item with an implicit data-mapping
+//   attribute has corresponding storage in the device data environment prior
+//   to a task encountering the construct on which the map clause appears,
+//   only that part of the original storage will have corresponding storage in
+//   the device data environment as a result of the map clause" (5.2 §5.8.3
+//   p.154 l.18-21; the same text in 5.0 §2.19.7.1 p.320 l.18-21). The
+//   OpenMP Examples document this form as working (target_struct_map.4,
+//   Case 1: "Explicitly mapping S1.p, S1.a, and S1.b rather than S1 avoids
+//   mapping the entire structure").
+// - same-compiler controls (correct, 4 202 dev= 1 on CCE 19, 20, 21, 21.0.4):
+//   s.big added to the target data map (the whole structure present); no
+//   target data and map(s.p[:N], s.a, s.b) on the target construct (the
+//   Examples' Case 3, 5.2 §5.8.3 p.154 l.22-27). Both are files now
+//   (controls/cce-c-implicit-struct-map-partly-present-whole-control.c and
+//   controls/cce-c-implicit-struct-map-partly-present-target-only-control.c);
+//   re-run 2026-11-01 on MI300A, HSA_XNACK 0 and 1: correct on CCE 19, 20,
+//   21, 21.0.4 and on AFAR, while this file fails on CCE 19, 20, 21, 21.0.4
+//   and is correct on AFAR (results/triage2/cce.jsonl).
+// - also: the Examples' Case 2 (target data map(s.p[:N]), then target
+//   map(s.p[:0], s.a, s.b) with s implicit) stops the same way on every CCE
+//   cell; libgomp's target-link-2.c (declare target link(arr), enter data
+//   map(arr[5:10]), then a target region that references arr) stops with the
+//   same message on CCE 19, 20, 21 (gfx90a): an implicit map (5.2 §5.8.1
+//   p.148 l.9-11) of a partly present array.
+// - other families: AFAR amdclang prints 4 202 dev= 1 (this file and the
+//   three Examples cases, gfx942 X0 and X1, gfx90a). NVHPC nvc 25.11 and 26.9
+//   (A100, separate and managed memory) fail this file at run time, exit
+//   status 1, with a different message: "FATAL ERROR: variable in data clause
+//   is partially present on the device: name=s" at the target construct (the
+//   present table lists s.a, s.b and, in separate memory, s.p[:100]). That is
+//   the OpenACC runtime's partial-presence error, and it reaches further than
+//   CCE's: NVHPC also fails the whole-structure control (s.big added, so every
+//   member is present, each as its own entry) that CCE and AFAR run correctly,
+//   and runs the target-only control correctly. All four gate environments
+//   agree on both releases and both memory modes (site matrix rows,
+//   2026-11-01, c on another GPU; a rerun of the file and both controls, three
+//   runs each, in a, b, d on GPU 0 and c on GPU 1:
+//   results/triage2/wingtip/nvhpc/nv.[abcd].jsonl). The Examples program's
+//   SIGSEGV on NVHPC is the 8 MB stack (its three structures hold 12 MB): with
+//   a 64 MB stack (ulimit -s 65536) it stops at Case 1 with the same
+//   partial-presence error (name=S1; nv3.jsonl). The failure is NVHPC's own
+//   and not CCE's, so this finding stays CCE's and the site shows NVHPC as
+//   failing another way; an NVHPC finding (the whole-structure control is the
+//   cleaner reproducer) is not made here. GCC 16.2 does not compile this file:
+//   the target data map list is the trigger of an internal compiler error
+//   on both targets (gcc-c-target-data-struct-pointer-section-ice.c).
+// - harvest: dev programs h2-ompex-target-struct-map-4-c and
+//   h2-gomp-ccc-target-link-2 (data/bench/harvest2), wrong_answer on every CCE
+//   cell, gate confirmed on gfx90a.
+// - legality: offload.engine.prerun.check accepts it (the rules with the race
+//   rule, and the AFAR clang front end), and accepts both controls (re-checked
+//   2026-11-01, Tuolumne pbatch; results/triage2/legal2.json). The rule it
+//   relies on is the one quoted above (5.2 §5.8.3 p.154 l.18-21: the part of
+//   an implicitly mapped list item that is present is the only part mapped);
+//   AFAR runs the file correctly, and the OpenMP Examples document the form.
+// CCE:  craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+//       -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942 -fopenmp-version=52 -O2
+// Run:  OMP_TARGET_OFFLOAD=mandatory ./a.out
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#define N 100
+struct foo { char big[200000]; float a, b; float *p; };
+#pragma omp begin declare target
+void saxpy(struct foo *s) { for (int i = 0; i < N; i++) s->p[i] = s->p[i] * s->a + s->b; }
+#pragma omp end declare target
+int main(void) {
+  struct foo s;
+  int dev = 0;
+  s.a = 2; s.b = 4; s.p = malloc(sizeof(float) * N);
+  for (int i = 0; i < N; i++) s.p[i] = i;
+#pragma omp target data map(s.p[:N], s.p, s.a, s.b)
+#pragma omp target map(from: dev)
+  { saxpy(&s); dev = !omp_is_initial_device(); }
+  printf("%.0f %.0f dev= %d\n", s.p[0], s.p[N - 1], dev);
+  int ok = s.p[0] == 4 && s.p[N - 1] == 202;
+  printf("RESULT ran_on_host=%d check=%s\n", !dev, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: craycc stops with "overlaps present region but is not contained" when a target region implicitly maps a partly mapped
+// + structure
+// end site

offload/_root/data/findings/harvest/cce-c-strided-target-update.c

@@ -0,0 +1,74 @@
+// # Finding: CCE craycc ignores the stride of an array section in
+// # `target update`: from(a[0:4:2]) copies a[0..3], to(a[1:4:2]) a[1..4]
+//
+// - compilers: CCE craycc 19.0.0, 20.0.2, 21.0.3, -O2: this file on MI300A
+//   gfx942 and MI250X gfx90a (HSA_XNACK=0); the 25 non-holdout upstream
+//   tests on both
+// - expected: a: 10 1 12 3 14 5 16 7 / strided bad= 0 contiguous bad= 0
+//   elementwise bad= 0
+// - actual: a: 10 11 12 13 4 5 6 7 / strided bad= 4 (the first 4 elements,
+//   not every second one); `to(a[1:4:2])` likewise writes a[1..4] (a probe,
+//   results/harvest/probe/src/strided_to.c and f1f2.jsonl, git-ignored)
+// - rule: "The list items may include array sections with stride
+//   expressions ... If a list item is an array or array section then it is
+//   treated as if it is replaced by each of its array elements in the
+//   clause" (OpenMP 5.2 §5.9 p.165 l.13-17), and a[0:4:2] denotes the
+//   elements "{ lower-bound, lower-bound + stride, lower-bound + 2 * stride,
+//   ... , lower-bound + ((length - 1) * stride) }" (5.2 §3.2.5 p.64
+//   l.22-23): a[0], a[2], a[4], a[6].
+// - copy mode only: with storage shared between host and device
+//   (HSA_XNACK=1) every device write is visible, so elements outside the
+//   section may differ legitimately (17 of the 25 non-holdout upstream tests
+//   fail there on AFAR and CCE alike; they are copy-only in
+//   catalog/harvest_copy_only.yaml).
+// - same-compiler controls (correct): from(b[0:4]) (contiguous); the four
+//   elements as four `target update from(c[k:1])`.
+// - other families: AFAR amdclang correct on this file and on all 25
+//   non-holdout upstream tests (gfx942 and gfx90a, X0). NVHPC nvc 25.11 and
+//   26.9 reject the stride ("expected a ]", this file and the 25 tests, both
+//   modes).
+// - vendor claim: "Non-contiguous updates are supported for normal array
+//   slice expressions that specify a lower bound, upper bound, and optional
+//   stride" (CCE 19.0.0, 20.0.2, 21.0.3 intro_openmp, data/index/claims/).
+// - upstream: the 25 non-holdout tests of llvm-project
+//   offload/test/offloading/strided_update/ fail on every CCE cell at X0
+//   (gfx942 and gfx90a; gate confirmed).
+// - legality: offload.engine.prerun.check accepts it (the rules and the AFAR
+//   clang front end).
+// CCE:  craycc -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa
+//       -Xopenmp-target=amdgcn-amd-amdhsa -march=gfx942 -fopenmp-version=52 -O2
+// Run:  OMP_TARGET_OFFLOAD=mandatory HSA_XNACK=0 ./a.out
+#include <stdio.h>
+#include <omp.h>
+int main(void) {
+  double a[8], b[8], c[8];
+  for (int i = 0; i < 8; i++) a[i] = b[i] = c[i] = i;
+  int on_host = 1, bad_a = 0, bad_b = 0, bad_c = 0;
+#pragma omp target data map(to: a[0:8], b[0:8], c[0:8])
+  {
+#pragma omp target map(from: on_host)
+    {
+      on_host = omp_is_initial_device();
+      for (int i = 0; i < 8; i++) { a[i] += 10; b[i] += 10; c[i] += 10; }
+    }
+#pragma omp target update from(a[0:4:2])
+#pragma omp target update from(b[0:4])
+#pragma omp target update from(c[0:1])
+#pragma omp target update from(c[2:1])
+#pragma omp target update from(c[4:1])
+#pragma omp target update from(c[6:1])
+  }
+  for (int i = 0; i < 8; i++) {
+    bad_a += a[i] != (i % 2 == 0 ? i + 10 : i);
+    bad_b += b[i] != (i < 4 ? i + 10 : i);
+    bad_c += c[i] != (i % 2 == 0 ? i + 10 : i);
+  }
+  printf("a:");
+  for (int i = 0; i < 8; i++) printf(" %g", a[i]);
+  printf("\nstrided bad= %d contiguous bad= %d elementwise bad= %d\n", bad_a, bad_b, bad_c);
+  printf("RESULT ran_on_host=%d check=%s\n", on_host, bad_a == 0 ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: target update of a strided array section (C) copies the contiguous range instead of every second element
+// end site

offload/_root/data/findings/harvest/cce-ftn-target-parallel-thread-query-ice.f90

@@ -0,0 +1,67 @@
+! # Finding: CCE ftn ICE "Could not find call"
+! # (v_acc_dataplacement.c) when a target parallel region assigns the result
+! # of omp_get_num_threads() or omp_get_thread_num()
+!
+! - compilers: CCE ftn 19.0.0, 20.0.2, 21.0.3, -O2: this file on MI300A
+!   gfx942 (HSA_XNACK 0 and 1); its variants on MI250X gfx90a (19.0.0,
+!   21.0.3); the upstream test on gfx942 (both modes) and gfx90a (gate
+!   confirmed)
+! - expected: compiles; prints x= <the team's size> (at least 1)
+! - actual: ftn: INTERNAL COMPILER ERROR: "Could not find call"
+!   (/workspace/crayftn/pdgcs/v_acc_dataplacement.c, line 4289 in 19.0.0,
+!   4343 in 20.0.2, 4378 in 21.0.3) (results/harvest/probe/f6.jsonl,
+!   findings_gfx942.jsonl)
+! - rule: a legal program (OpenMP 5.2 §10.1 parallel, §18.2.2
+!   omp_get_num_threads, §18.2.4 omp_get_thread_num; both routines are
+!   among the five CCE documents as supported in offload regions:
+!   intro_openmp, data/index/claims/hpe-cce-21.0.3-intro_openmp.txt). An ICE
+!   is a compiler bug.
+! - conditions (each a one-change variant, CCE 19.0.0 and 21.0.3): the same
+!   ICE with x = omp_get_thread_num(); with the result assigned to a private
+!   n, then x = n; with `target` and a nested `parallel` instead of the
+!   combined construct; with x an array element; with map(tofrom: x); with
+!   `use omp_lib, only: ...`; in a main program or a subroutine, with or
+!   without SAVE. No ICE: `x = 7` (no call); a call in an IF condition only
+!   (`if (omp_get_thread_num() == 0) then` ..., as in
+!   cce19-target-parallel-guarded-loop.f90); `target teams` with
+!   x = omp_get_num_teams() (x= 220).
+! - other families: AFAR amdflang compiles and runs it (x= 256, gfx942 at
+!   HSA_XNACK 0 and 1; parallel = T on the upstream test); NVHPC nvfortran
+!   25.11 and 26.9 compile and run it (x= 13824, A100, separate and
+!   managed).
+! - upstream: llvm-project offload/test/offloading/fortran/
+!   basic-target-parallel-region.f90 (CCE ICE on every CCE cell, gate
+!   confirmed on gfx90a); AOMP test/smoke/flang-313307-simple-spmd hits the
+!   same ICE.
+! - legality: offload.engine.prerun.check accepts it (the rules with the race
+!   rule, and the AFAR flang front end); only thread 0 writes x.
+! CCE:  ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm/<r>;
+!       module unload cray-mpich)
+! Run:  OMP_TARGET_OFFLOAD=mandatory ./a.out
+program tp_guarded
+   use omp_lib
+   implicit none
+   integer :: x, on_host
+   x = -1
+   on_host = 1
+   !$omp target map(from: on_host)
+   if (omp_is_initial_device()) then
+     on_host = 1
+   else
+     on_host = 0
+   end if
+   !$omp end target
+   !$omp target parallel map(from: x)
+   if (omp_get_thread_num() == 0) x = omp_get_num_threads()
+   !$omp end target parallel
+   print '(a,i0)', 'x= ', x
+   if (x >= 1) then
+     print '(a,i0,a)', 'RESULT ran_on_host=', on_host, ' check=pass'
+   else
+     print '(a,i0,a)', 'RESULT ran_on_host=', on_host, ' check=fail'
+   end if
+end program tp_guarded
+! site:
+! title: ftn: internal compiler error ("Could not find call") when a target parallel region assigns omp_get_num_threads() or
+! + omp_get_thread_num()
+! end site

offload/_root/data/findings/harvest/cce-named-constant-array-declare-target-routine-rejected.f90

@@ -0,0 +1,69 @@
+! # Finding (known-issues harvest): CCE rejects a module's named-constant array
+!   referenced in a declare target routine
+!
+! - source: holdout (a case of the known-issues harvest, held out); this file is the
+!   minimal form (data/reports/harvest-known/v-param-array-routine.f90)
+! - compilers: CCE 19.0.0, 20.0.2, 21.0.3 (ftn -fopenmp), gfx942 and gfx90a
+! - expected: the program compiles and prints RESULT ... check=pass: pick returns c(i), a
+!   module named constant [1.5, 2.5]
+! - actual: "ftn-7066 ftn: ERROR PICK ... Unsupported accelerator code error: Global in
+!   accelerator routine without declare -- c" on every CCE release and both architectures. HPE
+!   lists CAST-36609 ("ftn-7066 ... Global in accelerator routine without declare") as resolved
+!   in CCE 19.0.0 (data/index/claims/hpe-cce-19.0.0-release_info.txt line 114); this trigger remains
+! - control (same compiler): passes with a scalar named constant in the routine
+!   (c-param-scalar-routine.f90), with the array a named constant of the routine itself
+!   (c-param-array-local.f90), and with the array indexed in the target region itself
+!   (c-param-array-region-only.f90); all in data/reports/harvest-known/
+! - other families: AFAR compiles and runs it (check=pass); NVHPC 25.11 and 26.9 reject it too
+!   (harvest/nvhpc-named-constant-array-declare-target-routine-rejected.f90)
+! - legality: Fortran named constants are not variables; OpenMP 5.2's declare target
+!   requirement covers variables only: "A variable referenced in a target region but not the
+!   target construct that is not declared in the target region must appear in a declare target
+!   directive" (§13.8 p.286 l.31-32), and named constants are predetermined shared (§5.1.1 p.98
+!   l.11: "Assumed-size arrays and named constants are shared"); a named constant is a list
+!   item only "in clauses where it is explicitly allowed" (§3.2.1 p.61 l.10), and declare
+!   target's clauses do not name it. The pre-run check (rules and the AFAR front end) accepts the
+!   program
+! - the OpenACC form (routine seq; hk-015) fails the same way on CCE, but OpenACC 3.4
+!   §2.15.2 p.98 l.3623-3625 asks a declare directive for "Fortran module ... variables or arrays"
+!   used in accelerator routines, which may cover a named-constant array: not claimed here
+! - evidence: results/harvest-known/main.tioga (gate: confirmed), main (Tuolumne),
+!   the MI250X probe runs' output (results/harvest-known/logs/tioga/probe.f656gDkdAd9R.log and
+!   probe.f656iLRSBypT.log; their rows file probes.tioga.jsonl was not kept); the three controls on CCE 19/20/21, both modes:
+!   results/findings-baseline/harvest-cparam-controls.cce.jsonl
+module vpa_m
+  implicit none
+  real(8), parameter :: c(2) = [1.5d0, 2.5d0]
+contains
+  subroutine pick(i, x)
+    !$omp declare target
+    integer, intent(in) :: i
+    real(8), intent(out) :: x
+    x = c(i)
+  end subroutine pick
+end module vpa_m
+
+program vpa
+  use omp_lib
+  use vpa_m
+  implicit none
+  integer :: k, bad, hk_host
+  real(8) :: r(100)
+  r = 0
+  !$omp target teams distribute parallel do map(from: r)
+  do k = 1, 100
+    call pick(1 + mod(k, 2), r(k))
+  end do
+  bad = 0
+  do k = 1, 100
+    if (r(k) /= c(1 + mod(k, 2))) bad = bad + 1
+  end do
+  hk_host = 1
+  !$omp target map(tofrom: hk_host)
+  if (.not. omp_is_initial_device()) hk_host = 0
+  !$omp end target
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', hk_host, ' check=', merge('pass', 'fail', bad == 0)
+end program vpa
+! site:
+! title: ftn rejects a module's named-constant array referenced in a declare target routine
+! end site

offload/_root/data/findings/harvest/cce-use-device-ptr-c-ptr-not-converted.f90

@@ -0,0 +1,64 @@
+! # Finding (known-issues harvest): CCE does not convert a C_PTR list item of
+!   use_device_ptr: the region sees the host address
+!
+! - source: the NVIDIA forum topic 290317 (nvfortran dropping use_device_addr on an allocatable,
+!   TPR 36867) gave data/bench/harvest-known hk-040, which compares the use_device_addr address of an
+!   allocatable with the use_device_ptr address of a C_PTR to it; this file is the use_device_ptr
+!   half (data/reports/harvest-known/v040-ptr-print.f90)
+! - compilers: CCE 19.0.0, 20.0.2, 21.0.3 (ftn -fopenmp), copy mode: gfx90a (Tioga, HSA_XNACK=0)
+!   and gfx942 at HSA_XNACK=0 (MI300A); at HSA_XNACK=1 on MI300A the mapped address is the host
+!   address, so the missing conversion is not visible (check=pass)
+! - expected: seen equals mapped (the device address of tab), RESULT ... check=pass
+! - actual: seen equals host: e.g. CCE 19 "host 48BEC0 mapped 155544200000 seen 48BEC0", the same
+!   on 20 and 21; RESULT ... check=fail. A device kernel given this pointer would read host memory.
+!   The observation does not rest on omp_get_mapped_ptr (a routine of the compiler under test):
+!   in copy mode device memory is separate, so seen = the host address is wrong whatever it returns
+! - control (same compiler): use_device_addr(tab) on the allocatable itself gives the mapped
+!   address (data/reports/harvest-known/v040-addr.f90, check=pass on CCE 19/20/21)
+! - other families: AFAR converts it (seen = mapped); NVHPC 25.11 and 26.9 abort at the construct
+!   (harvest/nvhpc-use-device-ptr-c-ptr-not-found.f90)
+!   This file uses omp_get_mapped_ptr as the reference: AFAR at HSA_XNACK=1 (MI300A) returns a
+!   null pointer for it, the known defect of afar-xnack1-target-is-present.f90 (nothing is
+!   recorded present in unified memory), so that cell fails for another reason
+! - legality: "If a list item that appears in a use_device_ptr clause is of type C_PTR and
+!   points to a data entity that is mapped to the device data environment, references to the list
+!   item in the structured block ... are converted into references to a device pointer that is
+!   local to the structured block and that refers to the device address of the corresponding
+!   entity" (OpenMP 5.2 §5.4.8 p.122 l.1-5); tab is mapped by target enter data and cp =
+!   c_loc(tab); the C_PTR form is the one 5.2 keeps (the non-C_PTR form is deprecated, l.8-10).
+!   omp_get_mapped_ptr is OpenMP 5.1 (§3.8.11); the pre-run check accepts the program
+! - evidence: results/harvest-known/main.tioga (hk-040, gate: confirmed); the MI250X probe runs' output
+!   (results/harvest-known/logs/tioga/probe.f656gDkdAd9R.log and probe.f656k2mjQdoD.log; their rows file
+!   probes.tioga.jsonl was not kept); results/harvest-known/probes.tuolumne.jsonl (MI300A, v040-ptr.f90:
+!   fail at HSA_XNACK=0, pass at 1)
+program v040pp
+  use iso_c_binding
+  use omp_lib
+  implicit none
+  integer, parameter :: n = 1024
+  integer, allocatable, target :: tab(:)
+  type(c_ptr), target :: cp
+  type(c_ptr) :: p_ptr, p_map
+  integer :: hk_host
+  allocate(tab(n))
+  tab = 7
+  !$omp target enter data map(to: tab)
+  p_map = omp_get_mapped_ptr(c_loc(tab), omp_get_default_device())
+  cp = c_loc(tab)
+  !$omp target data use_device_ptr(cp)
+  p_ptr = cp
+  !$omp end target data
+  !$omp target exit data map(delete: tab)
+  print '(a,z0)', 'host   ', transfer(c_loc(tab), 0_c_intptr_t)
+  print '(a,z0)', 'mapped ', transfer(p_map, 0_c_intptr_t)
+  print '(a,z0)', 'seen   ', transfer(p_ptr, 0_c_intptr_t)
+  print '(a,z0)', 'loc(cp) ', transfer(c_loc(cp), 0_c_intptr_t)
+  hk_host = 1
+  !$omp target map(tofrom: hk_host)
+  if (.not. omp_is_initial_device()) hk_host = 0
+  !$omp end target
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', hk_host, ' check=', merge('pass', 'fail', c_associated(p_ptr, p_map))
+end program v040pp
+! site:
+! title: use_device_ptr does not convert a C_PTR list item: the region sees the host address
+! end site

offload/_root/data/findings/harvest/cce21-declare-target-link-module-variable-write-lost.f90

@@ -0,0 +1,63 @@
+! # Finding: CCE 21 ftn loses the target region's write to a module
+! # variable in a declare target link clause that the target construct maps
+! # tofrom (CCE 19 and 20 correct)
+!
+! - compilers: CCE ftn 21.0.3 and 21.0.4, -O2: this file on MI300A gfx942
+!   (HSA_XNACK 0 and 1); the two AOMP tests it comes from also on MI250X
+!   gfx90a with 21.0.3.
+! - expected: v= 1 dev= T
+! - actual: v= 0 dev= T (the region runs on the device; the original v keeps
+!   its value), every run, both memory modes.
+! - rule: the link clause "does not map the list items. Instead, they are
+!   mapped according to the data-mapping rules described in Section 5.8"
+!   (5.2 §5.8.5 p.159 l.24-27), so map(tofrom: v) on the target construct
+!   maps v with a reference count of one and on exit "the original list item
+!   is updated as if the list item appeared in a from clause on a target
+!   update directive" (5.2 §5.8.3 p.154 l.3-5). OpenMP 4.5 already has the
+!   link clause.
+! - regression: CCE 19.0.0 and 20.0.2 print v= 1 dev= T (gfx942 both modes;
+!   gfx90a).
+! - same-compiler controls (CCE 21.0.3 and 21.0.4 correct, v= 1 dev= T):
+!   the same map on an enclosing target data construct (target data
+!   map(tofrom: v), then target without a map of v); v without the declare
+!   target directive. (With enter(v) instead of link(v) v= 0 is the expected
+!   result: the variable is present for the whole program and the exit update
+!   happens only at a reference count of one, 5.2 §5.8.3 p.154 l.3-5; AFAR and
+!   CCE 21 print v= 0, CCE 19 and 20 reject enter.)
+! - other families: AFAR amdflang prints v= 1 dev= T (gfx942 X0 and X1,
+!   gfx90a).
+! - harvest: dev programs h2-aomp-smoke-fort-declare-target-link-2 and
+!   h2-aomp-fortran-map-tests-even-basicer-example (data/bench/harvest2; AOMP
+!   test/smoke-fort/declare-target-link-2 and
+!   test/fortran-map-tests/even-basicer-example.f95), wrong_answer on CCE 21
+!   only, gate confirmed on gfx90a.
+! - legality: offload.engine.prerun.check accepts it (the rules with the race
+!   rule, and the AFAR flang front end).
+! CCE:  ftn -fopenmp -O2 (module load cce/<v> craype-accel-amd-gfx942 rocm/<r>;
+!       module unload cray-mpich)
+! Run:  OMP_TARGET_OFFLOAD=mandatory ./a.out
+module m
+  implicit none
+  integer :: v = 0
+  !$omp declare target link(v)
+end module m
+program p
+  use m
+  use omp_lib
+  implicit none
+  logical :: dev
+  dev = .false.
+  !$omp target map(tofrom: v) map(from: dev)
+  v = 1
+  dev = .not. omp_is_initial_device()
+  !$omp end target
+  print '(a,i0,a,l1)', 'v= ', v, ' dev= ', dev
+  if (v == 1) then
+    print '(a,i0,a)', 'RESULT ran_on_host=', merge(0, 1, dev), ' check=pass'
+  else
+    print '(a,i0,a)', 'RESULT ran_on_host=', merge(0, 1, dev), ' check=fail'
+  end if
+end program p
+! site:
+! title: ftn 21 loses a target region's write to a declare target link module variable mapped tofrom
+! end site