offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/catalog/afar-flang-named-critical-link.f90

@@ -0,0 +1,67 @@
+! # Draft finding: omp52-w-critical-named on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-w-critical-named (f90, version 52, sha256 dabbabc4b167391a)
+! - expected: None (None; )
+! - actual: rejected  (link_undefined_symbol: ld.lld: error: undefined symbol: __kmpc_critical_with_hint)
+! - verdict: compiler_bug by rule R10b-own-link-or-hang: a link failure on symbols the compiler's own generated code needs, or a
+!   compile that does not finish, on a legal program: the compiler's defect (never a rejection)
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); NVHPC is no witness: it does not implement a feature the
+!   program uses (NVFORTRAN-F-1196-OpenMP - omp critical is not supported in GPU
+!   region); 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
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenMP 5.2, free-form Fortran; catalog widening). Do not edit.
+! id: omp52-w-critical-named
+! primary atom: form.omp.critical_named
+! atoms: form.omp.critical_named
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: a named critical construct in a target parallel loop
+! spec: OpenMP 5.2 §15.2, p.299 (critical construct); its binding thread set is the contention group, so a target parallel region
+! (one team) is used
+program wide_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), ref(n)
+  integer :: s, t
+  integer :: i, host_flag
+  logical :: ok
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 2*i + 1
+  end do
+  host_flag = 1
+  s = 0
+  !$omp target parallel do map(to: a) map(tofrom: s, host_flag) private(t)
+  do i = 1, n
+    !$omp critical (wsum)
+    t = s
+    s = t + a(i)
+    !$omp end critical (wsum)
+    if (i == 1) host_flag = merge(1, 0, omp_is_initial_device())
+  end do
+  !$omp end target parallel do
+  ok = s == n*(n + 1)/2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program wide_prog
+! site:
+! title: amdflang/amdclang: a named critical (Fortran) or a critical with hint (C) in a target region fails at the device link
+! + (__kmpc_critical_with_hint undefined)
+! control: ../vendor/checks/src/afar/control/afar-flang-named-critical-link-control.f90 the same loop on the host (parallel do
+! + instead of
+! + target
+! + parallel do)
+! end site

offload/_root/data/findings/catalog/afar-flang-ordered-wrong.f90

@@ -0,0 +1,78 @@
+! # Draft finding: omp52-clause-ordered on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-ordered (f90, version 52, sha256 50b2a05bbea64844)
+! - expected: check=pass (trusted; elision + model)
+! - actual: wrong_answer check=fail (check_fail: ran_on_host=0 check=fail)
+! - verdict: compiler_bug by rule R20-runtime-bug: a legal program fails at run time, deterministically, against an expected value
+!   from two or more independent sources with an executed witness, and another toolchain, mode, arch or the elision gives the
+!   expected value
+! - reason: expected trusted check=pass (elision + model): stored main verdict: elision + model agree; witnesses: afar/gfx942/copy
+!   (port:omp52-c-clause-ordered), afar/gfx942/unified (port:omp52-c-clause-ordered), elision
+! - citations: RUL-DERIVED-NEEDS-EXECUTION (rulings.md); RUL-WITNESS-PER-MODE (rulings.md);
+!   RUL-SAME-COMPILER-RUNS (rulings.md)
+! - legality: legal (legal by construction: offload.engine.gen / c_gen / acc_gen check every program against the catalog rules
+!   and the
+!   offload scope as it is built (no compiler))
+! - witnesses: afar/gfx942/copy (port:omp52-c-clause-ordered), afar/gfx942/unified (port:omp52-c-clause-ordered), elision
+! - withdrawn: none
+!
+! Generated by compliance.gen (OpenMP 5.2, free-form Fortran). Do not edit.
+! id: omp52-clause-ordered
+! primary atom: omp.clause.ordered
+! 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
+  integer :: cnt, seq(n)
+  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
+  cnt = 0
+  seq = -1
+  !$omp target map(to: a) map(from: b) map(tofrom: cnt) map(from: seq) map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    !$omp parallel do default(none) shared(a, b, cnt, seq) ordered
+      do i = 1, n
+        b(i) = 2*a(i) + 1
+        !$omp ordered
+          cnt = cnt + 1
+          seq(i) = cnt
+        !$omp end ordered
+      end do
+    !$omp end parallel do
+  !$omp end target
+  ok = all(b == ref) .and. all(2*seq + 1 == ref)
+  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: amdflang: ordered regions in a parallel do in a target region do not run in iteration order
+! control: ../vendor/checks/src/afar/control/afar-flang-ordered-wrong-control.f90 the same parallel do on the host (the target
+! + directive
+! + removed)
+! end site
+! spec (requirement): Ordered regions of a worksharing loop with an ordered clause execute sequentially in the order
+!   of the loop iterations.
+! "the threads in the team that is executing the worksharing-loop region execute ordered regions sequentially in the
+!   order of the loop iterations." (5.2 §15.10.2 p.330 l.21-22)
+! spec (requirement): An ordered construct without clauses has the effect of the threads clause.
+! "If no clauses are specified, the effect is as if the threads parallelization-level clause was specified." (5.2
+!   §15.10.2 p.330 l.20-21)
+! spec (this program): The ordered region increments cnt and records seq(i), so the regions run in iteration order and
+!   seq(i) = i for every i; on the device amdflang runs them out of order and check=fail results.

offload/_root/data/findings/catalog/afar-flang-reduction-minus-rejected.f90

@@ -0,0 +1,77 @@
+! # Draft finding: omp52-clause-in_reduction-minus on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-in_reduction-minus (f90, version 52, sha256 685f776281adfd53)
+! - expected: None (None; )
+! - actual: rejected  (diagnostic: <tmpdir>/omp52-clause-in_reduction-minus.f90:31:19: error: The minus reduction operator is
+!   deprecated since OpenMP 5.2 and is not supported in the REDUCTION clause.)
+! - verdict: compiler_bug by rule R11-compile-rejection: a legal program the compiler rejects with a diagnostic (or whose link fails
+!   on symbols the compiler's own code needs, or whose compile does not finish) while another compiler family compiles it
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal (legal by construction: offload.engine.gen / c_gen / acc_gen check every program against the catalog rules
+!   and the
+!   offload scope as it is built (no compiler))
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.gen (OpenMP 5.2, free-form Fortran). Do not edit.
+! id: omp52-clause-in_reduction-minus
+! primary atom: omp.clause.in_reduction.minus
+! 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
+  integer :: s, sref
+  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
+  s = 0
+  sref = 0
+  do i = 1, n
+    sref = sref - a(i)
+  end do
+  !$omp taskgroup task_reduction(-: s)
+    !$omp target map(to: a) map(from: b) map(tofrom: host_flag) in_reduction(-: s)
+      host_flag = merge(1, 0, omp_is_initial_device())
+      do i = 1, n
+        b(i) = 2*a(i) + 1
+        s = s - a(i)
+      end do
+    !$omp end target
+  !$omp end taskgroup
+  ok = all(b == ref) .and. (s == sref)
+  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: amdflang: the deprecated - reduction identifier in task_reduction/in_reduction is rejected as not supported
+! control: ../vendor/checks/src/afar/control/afar-flang-reduction-minus-rejected-control.f90 the reduction identifier + instead of -
+! end site
+! spec (requirement): The minus operator is still a reduction identifier in OpenMP 5.2 (deprecated, not removed), so a
+!   conforming compiler accepts it in reduction-type clauses.
+! "following operators: +, - (deprecated), *, .and., .or., .eqv., .neqv." (5.2 §5.5.1 p.124 l.23)
+! spec (requirement): The 5.2 list of changes states that the minus operator was deprecated, not removed.
+! "The minus (-) operator for reductions was deprecated (see Section 5.5.5)." (5.2 §B.2 p.627 l.18)
+! spec (requirement): The reduction identifier of task_reduction and in_reduction must match a previously declared
+!   identifier of the same name and type; Table 5.2 lists - (deprecated) as implicitly declared for Fortran numeric
+!   types.
+! "The reduction identifier must match a previously declared reduction identifier of the same name and type for each
+!   of the list items." (5.2 §5.5.5 p.131 l.4-5)
+! spec (this program): task_reduction(-: s) and in_reduction(-: s) use the deprecated but valid minus identifier;
+!   amdflang rejects it with a diagnostic that the minus reduction operator is not supported in the reduction clause.

offload/_root/data/findings/catalog/afar-flang-reduction-task-ice.f90

@@ -0,0 +1,68 @@
+! # Draft finding: omp52-clause-reduction-task on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-reduction-task (f90, version 52, sha256 0181c241953a07c1)
+! - expected: None (None; )
+! - actual: ice  (ice: Call parameter type does not match function signature!)
+! - verdict: compiler_bug by rule R10-compile-ice: an internal compiler error (or the compiler rejecting code it generated) on a
+!   legal program: always the compiler's defect
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal (legal by construction: offload.engine.gen / c_gen / acc_gen check every program against the catalog rules
+!   and the
+!   offload scope as it is built (no compiler))
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.gen (OpenMP 5.2, free-form Fortran). Do not edit.
+! id: omp52-clause-reduction-task
+! primary atom: omp.clause.reduction.task
+! 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
+  integer :: s, sref
+  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
+  s = 0
+  sref = 0
+  do i = 1, n
+    sref = sref + a(i)
+  end do
+  !$omp target map(to: a) map(from: b) map(tofrom: host_flag) map(tofrom: s)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    !$omp parallel default(none) shared(a, b, s)
+      !$omp do reduction(task, +: s)
+        do i = 1, n
+          b(i) = 2*a(i) + 1
+          s = s + a(i)
+        end do
+      !$omp end do
+    !$omp end parallel
+  !$omp end target
+  ok = all(b == ref) .and. (s == sref)
+  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: amdflang: "Call parameter type does not match function signature!" for sections, and for reduction(task), in a target
+! + region
+! control: ../vendor/checks/src/afar/control/afar-flang-reduction-task-ice-control.f90 reduction(+: s) without the task modifier
+! same_as: catalog/afar-flang-sections-in-target-ice
+! end site

offload/_root/data/findings/catalog/afar-flang-sections-in-target-ice.f90

@@ -0,0 +1,67 @@
+! # Draft finding: omp52-w-sections on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-w-sections (f90, version 52, sha256 d299f7f016bae1e6)
+! - expected: None (None; )
+! - actual: ice  (ice: Call parameter type does not match function signature!)
+! - verdict: compiler_bug by rule R10-compile-ice: an internal compiler error (or the compiler rejecting code it generated) on a
+!   legal program: always the compiler's defect
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal: offload.engine.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); NVHPC is no witness: it does not implement a feature the
+!   program uses (NVFORTRAN-F-1196-OpenMP - omp sections is not supported in GPU
+!   region); 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
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenMP 5.2, free-form Fortran; catalog widening). Do not edit.
+! id: omp52-w-sections
+! primary atom: omp.directive.sections
+! atoms: omp.directive.sections
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: a sections construct with two sections in a target parallel region
+! spec: OpenMP 5.2 §11.3, p.243 (sections construct)
+program wide_prog
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), ref(n)
+  integer :: i, host_flag
+  logical :: ok
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 2*i + 1
+  end do
+  host_flag = 1
+  !$omp target parallel map(to: a) map(tofrom: b, host_flag)
+  !$omp sections
+  !$omp section
+  do i = 1, n/2
+    b(i) = 2*a(i) + 1
+  end do
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp section
+  do i = n/2 + 1, n
+    b(i) = a(i) + a(i) + 1
+  end do
+  !$omp end sections
+  !$omp end target parallel
+  ok = all(b == ref)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program wide_prog
+! site:
+! title: amdflang: "Call parameter type does not match function signature!" for sections, and for reduction(task), in a target
+! + region
+! control: ../vendor/checks/src/afar/control/afar-flang-sections-in-target-ice-control.f90 the same sections on the host (parallel
+! + instead of
+! + target parallel)
+! end site

offload/_root/data/findings/catalog/afar-flang-workdistribute-ice.f90

@@ -0,0 +1,71 @@
+! # Draft finding: omp60-directive-target_teams_workdistribute on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp60-directive-target_teams_workdistribute (f90, version 60, sha256 d86b846044944953)
+! - expected: None (None; )
+! - actual: ice  (ice: PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace
+!   and instructions to reproduce the bug.)
+! - verdict: compiler_bug by rule R10-compile-ice: an internal compiler error (or the compiler rejecting code it generated) on a
+!   legal program: always the compiler's defect
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal (legal by construction: offload.engine.gen / c_gen / acc_gen check every program against the catalog rules
+!   and the
+!   offload scope as it is built (no compiler))
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.gen (OpenMP 6.0, free-form Fortran). Do not edit.
+! id: omp60-directive-target_teams_workdistribute
+! primary atom: omp.directive.target_teams_workdistribute
+! legal: yes
+! observable: yes
+! ran_on_host: probe (a target region just before the region of interest, which may not call the OpenMP API)
+! evidence: construct
+! needs: none
+! std: f2008
+! unverified: no toolchain compiles this (6.0 workdistribute), so the on_dev evidence is untested here
+! derivation (check=pass): on_dev is a declare_target variable: the first target region sets the device's copy to 1, and it keeps
+! derivation: its value on the device; target teams workdistribute divides the array assignment b = 2*a + on_dev into units of work
+! derivation: each executed once (6.0 §13.5 p.412), so b(i) = 2*i + 1 on the device, mapped from: b = ref; the check accepts
+module gen_mod
+  implicit none
+  integer :: on_dev = 0
+  !$omp declare target(on_dev)
+end module gen_mod
+
+program gen_prog
+  use omp_lib, only: omp_is_initial_device
+  use gen_mod
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable, target :: a(:), b(:)
+  integer :: ref(n)
+  integer :: i, host_flag
+  logical :: ok
+  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
+  !$omp target map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    on_dev = 1
+  !$omp end target
+  !$omp target teams workdistribute map(to: a) map(from: b) default(none) shared(a, b, on_dev)
+    b = 2*a + on_dev
+  !$omp end target teams workdistribute
+  if (all(b == 2*a)) host_flag = 1
+  ok = all(b == ref)
+  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: amdflang -fopenmp-version=60: compiler crash in MapInfoOp for target teams workdistribute
+! control: ../vendor/checks/src/afar/control/afar-flang-workdistribute-ice-control.f90 a plain target construct around the array
+! + assignment
+! + instead of target teams workdistribute
+! end site

offload/_root/data/findings/catalog/c-allocate-const-mem-firstprivate-wrong.c

@@ -0,0 +1,79 @@
+// # Draft finding: omp52-c-w-allocate-const-firstprivate on afar
+//
+// - compiler: afar
+// - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-w-allocate-const-firstprivate (c, version 52, sha256 2f1a38cbd60a463c)
+// - expected: check=pass (trusted; elision + model)
+// - actual: wrong_answer check=fail (check_fail: ran_on_host=0 check=fail)
+// - oracle audit: run on AFAR, CCE 19, 20, 21 (copy mode) and NVHPC: no toolchain passes the original (NVHPC rejects the clauses), so the mutant cannot be credited (unaudited, not weak); in sequential elision the original prints check=pass and the mutant (x's contribution removed) check=fail, so the check depends on the firstprivate value
+// - verdict: compiler_bug by rule R20-runtime-bug: a legal program fails at run time, deterministically, against an expected value from two or more independent sources with an executed witness, and another toolchain, mode, arch or the elision gives the expected value
+// - reason: expected trusted check=pass (elision + model): stored main verdict: elision + model agree; witnesses: elision
+// - citations: RUL-DERIVED-NEEDS-EXECUTION (rulings.md); RUL-WITNESS-PER-MODE (rulings.md); RUL-SAME-COMPILER-RUNS (rulings.md); RUL-PRESENCE-WITNESS (rulings.md); RUL-METAMORPHIC-OTHER-FAMILY (rulings.md)
+// - legality: legal: offload.engine.prerun.check accepts it (rerun: offload.engine.rules with the
+//   race rule and the restriction checks, and the AFAR clang front end, not under test here); no
+//   compiler under test, gfortran or gcc is a legality witness
+// - witnesses: elision
+// - withdrawn: none
+//
+// Generated by compliance.widen (OpenMP 5.2, C11; catalog widening). Do not edit.
+// id: omp52-c-w-allocate-const-firstprivate
+// primary atom: pair.omp.clause.allocate+omp.clause.firstprivate
+// atoms: pair.omp.clause.allocate+omp.clause.firstprivate, omp.clause.allocate, omp.clause.firstprivate
+// legal: yes
+// observable: yes
+// ran_on_host: inside the target region of interest
+// evidence: construct
+// needs: none
+// std: c11
+// feature: a firstprivate scalar allocated with omp_const_mem_alloc (uses_allocators) on a target loop
+// spec: the parts' own programs
+// pair of: omp.clause.allocate + omp.clause.firstprivate (each has a program of its own)
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+enum { n = 64 };
+
+int main(void) {
+  int a[n], b[n], ref[n];
+  int host_flag = 1;
+  int x = 5;
+  for (int i = 0; i < n; i++) {
+    a[i] = i + 1;
+    b[i] = 0;
+    ref[i] = i + 1 + 5;
+  }
+  #pragma omp target teams distribute parallel for map(to: a) map(from: b) map(tofrom: \
+      host_flag) firstprivate(x) allocate(omp_const_mem_alloc: x) \
+      uses_allocators(omp_const_mem_alloc)
+  for (int i = 0; i < n; i++) {
+    b[i] = a[i] + x;
+    if (i == 0) host_flag = omp_is_initial_device();
+  }
+  bool ok = true;
+  for (int i = 0; i < n; i++)
+    ok = ok && (b[i] == ref[i]);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: craycc: a firstprivate scalar allocated with omp_const_mem_alloc has the wrong value on the device
+// control: ../vendor/checks/src/other/control/c-allocate-const-mem-firstprivate-wrong-control.c the allocate and uses_allocators
+// + clauses
+// + removed
+// + (x firstprivate only)
+// end site
+// spec (requirement): Variables in the constant memory space may be initialized through the firstprivate clause.
+// "Variables allocated in the omp_const_mem_space memory space may be initialized through the firstprivate clause"
+//   (5.2 §6.1 p.171 l.9-10)
+// spec (requirement): A firstprivate list item that also appears in allocate gets its storage from that allocator and
+//   is initialized from the original list item.
+// "If a list item in the clause also appears in a data-sharing attribute clause on the same directive that privatizes
+//   the list item, allocations that arise from that list item in the clause will be provided by the memory
+//   allocator." (5.2 §6.6 p.178 l.12-14)
+// spec (requirement): The new list item of a firstprivate clause is initialized from the original list item.
+// "In addition, the new list item is initialized from the original list item that exists before the construct." (5.2
+//   §5.4.4 p.112 l.11-12)
+// spec (this program): firstprivate(x) allocate(omp_const_mem_alloc: x) with uses_allocators(omp_const_mem_alloc) is
+//   the form 5.2 names for constant memory, so every device copy of x must hold 5; craycc yields the wrong value on
+//   the device.

offload/_root/data/findings/catalog/cce-acc-allocate-in-compute-crash.f90

@@ -0,0 +1,65 @@
+! # Draft finding: acc34-w-allocate-in-device on cce19
+!
+! - compiler: cce19
+! - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog acc34-w-allocate-in-device (f90, version 34, sha256 bc9f4dc73a5f7637)
+! - expected: check=pass (trusted; elision + model)
+! - actual: crash  (crash: SIGABRT)
+! - verdict: compiler_bug by rule R20-runtime-bug: a legal program fails at run time, deterministically, against an expected value
+!   from two or more independent sources with an executed witness, and another toolchain, mode, arch or the elision gives the
+!   expected value
+! - reason: expected trusted check=pass (elision + model): stored main verdict: elision + model agree; witnesses: elision
+! - citations: RUL-DERIVED-NEEDS-EXECUTION (rulings.md); RUL-WITNESS-PER-MODE (rulings.md);
+!   RUL-SAME-COMPILER-RUNS (rulings.md); RUL-PRESENCE-WITNESS (rulings.md); RUL-METAMORPHIC-OTHER-FAMILY
+!   (rulings.md)
+! - legality: legal: 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
+! - witnesses: elision
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenACC 3.4, free-form Fortran; catalog widening). Do not edit.
+! id: acc34-w-allocate-in-device
+! primary atom: base.device.allocate
+! atoms: base.device.allocate
+! legal: yes
+! observable: yes
+! ran_on_host: inside the compute region of interest (acc_on_device)
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: ALLOCATE and DEALLOCATE of a local allocatable array in a target region
+! spec: OpenACC 3.4 §1.8, p.16: Fortran 2008 is a normative base language (the features whose use is unspecified are listed there;
+! this is not one of them)
+program wide_prog
+  use openacc, only: acc_device_host, acc_on_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), ref(n)
+  integer :: i, host_flag
+  logical :: ok
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 2*i + 1
+  end do
+  host_flag = 1
+  !$acc serial copyin(a) copyout(b) copy(host_flag)
+    host_flag = merge(1, 0, acc_on_device(acc_device_host))
+    block
+      integer, allocatable :: w(:)
+      allocate(w(n))
+      w = 2*a + 1
+      b = w
+      deallocate(w)
+    end block
+  !$acc end serial
+  ok = all(b == ref)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program wide_prog
+! site:
+! title: ftn: ALLOCATE/DEALLOCATE of a local allocatable in device code aborts (SIGABRT), OpenMP and OpenACC
+! control: ../vendor/checks/src/cce/control/cce-acc-allocate-in-compute-crash-control.f90 w a fixed-size local array (no
+! + ALLOCATE/DEALLOCATE)
+! same_as: catalog/cce-flang-allocate-in-target-crash
+! end site

offload/_root/data/findings/catalog/cce-acc-character-dummy-routine-ice.f90

@@ -0,0 +1,81 @@
+! # Draft finding: acc34-w-routine-character on cce20
+!
+! - compiler: cce20
+! - toolchain: cce20; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog acc34-w-routine-character (f90, version 34, sha256 976490e860a6112c)
+! - expected: None (None; )
+! - actual: ice  (ice: INTERNAL COMPILER ERROR:  "Bad cast from fcd to ... " (/workspace/crayftn/pdgcs/llvm-uex-expr.c, line 620,
+!   version 668d73f9607c0349bd23641a3a25a1acfac374de))
+! - verdict: compiler_bug by rule R10-compile-ice: an internal compiler error (or the compiler rejecting code it generated) on a
+!   legal program: always the compiler's defect
+! - reason: 
+! - citations: RUL-COMPILE-TIME (rulings.md)
+! - legality: legal: 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
+! - witnesses: none
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenACC 3.4, free-form Fortran; catalog widening). Do not edit.
+! id: acc34-w-routine-character
+! primary atom: pair.base.device.routine_call+base.device.character
+! atoms: pair.base.device.routine_call+base.device.character, base.device.routine_call, base.device.character
+! legal: yes
+! observable: yes
+! ran_on_host: inside the compute region of interest (acc_on_device)
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: a device routine with a CHARACTER(len=*) dummy
+! spec: the parts' own programs
+! pair of: base.device.routine_call + base.device.character (each has a program of its own)
+module wmod
+  implicit none
+contains
+  integer function code(c)
+    !$acc routine seq
+    character(len=*), intent(in) :: c
+    code = ichar(c(1:1)) + len(c)
+  end function code
+end module wmod
+
+program wide_prog
+  use openacc, only: acc_device_host, acc_on_device
+  use wmod
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), ref(n)
+  character(len=8) :: s
+  integer :: i, host_flag
+  logical :: ok
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 97 + mod(i, 8) + 1
+  end do
+  host_flag = 1
+  !$acc parallel loop copyin(a) copyout(b) copy(host_flag) private(s)
+  do i = 1, n
+    s = 'abcdefgh'
+    b(i) = code(s(1:mod(i, 8) + 1))
+    if (i == 1) host_flag = merge(1, 0, acc_on_device(acc_device_host))
+  end do
+  ok = all(b == ref)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program wide_prog
+! site:
+! title: ftn -h acc: internal compiler error "Bad cast from fcd" for a CHARACTER(len=*) dummy of a routine seq procedure
+! control: ../vendor/checks/src/cce/control/cce-acc-character-dummy-routine-ice-control.f90 the routine takes the character's
+! + code and
+! + length as
+! + integers instead of the CHARACTER(len=*) dummy
+! end site
+! spec (requirement): The routine directive tells the compiler to compile a procedure for the accelerator as well as
+!   the host.
+! "The routine directive is used to tell the compiler to compile the definition for a procedure, such as a function or
+!   C++ lambda, for an accelerator as well as for the host." (OpenACC 3.4 §2.15.1 p.91 l.3321-3323)
+! spec (requirement): A call to a seq routine may appear in any mode, including from a loop in a parallel region.
+! "A call to this procedure may appear in any mode." (OpenACC 3.4 §2.15.1 p.93 l.3404)
+! spec (this program): The seq routine code takes a character(len=*) dummy; the spec places no restriction on the
+!   argument types of a routine procedure (the glossary treats character variables as aggregate variables), so the
+!   call with a substring is legal, and ftn stops with an internal error (Bad cast from fcd).