offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/catalog/cce-acc-loop-seq-in-routine-wrong.f90

@@ -0,0 +1,81 @@
+! # Draft finding: acc34-w-loop-in-routine on cce19
+!
+! - compiler: cce19
+! - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog acc34-w-loop-in-routine (f90, version 34, sha256 1499c90f659f38cf)
+! - 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: 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-loop-in-routine
+! primary atom: base.device.loop_in_routine
+! atoms: base.device.loop_in_routine
+! legal: yes
+! observable: yes
+! ran_on_host: inside the compute region of interest (acc_on_device)
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: a loop seq construct inside a routine seq procedure called in a parallel loop
+! spec: OpenACC 3.4 §2.9 (loop construct) and §2.15.1 (routine seq: a loop construct in it must be seq)
+module wmod
+  implicit none
+contains
+  subroutine rowsum(x, s)
+    !$acc routine seq
+    integer, intent(in) :: x(:)
+    integer, intent(out) :: s
+    integer :: k
+    s = 0
+    !$acc loop seq
+    do k = 1, size(x)
+      s = s + x(k)
+    end do
+  end subroutine rowsum
+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)
+  integer :: a2(4, n)
+  integer :: k
+  integer :: i, host_flag
+  logical :: ok
+  do i = 1, n
+    a(i) = i
+    b(i) = 0
+    ref(i) = 10*i
+  end do
+  do i = 1, n
+    do k = 1, 4
+      a2(k, i) = k*i
+    end do
+  end do
+  host_flag = 1
+  !$acc parallel loop copyin(a2) copyout(b) copy(host_flag)
+  do i = 1, n
+    call rowsum(a2(:, i), b(i))
+    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: a loop seq construct inside a routine seq procedure gives wrong sums
+! control: ../vendor/checks/src/cce/control/cce-acc-loop-seq-in-routine-wrong-control.f90 the loop seq directive removed
+! end site

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

@@ -0,0 +1,62 @@
+! # Draft finding: acc34-w-stop-unreached on cce20
+!
+! - compiler: cce20
+! - toolchain: cce20; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog acc34-w-stop-unreached (f90, version 34, sha256 22669cbf97756bcb)
+! - expected: check=pass (trusted; elision + model)
+! - actual: crash Thread execution stopped at FILE ../../acc34-w-stop-unreached.f90 LINE 28 due to a regular STOP statement. ...
+!   (repeated; 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-stop-unreached
+! primary atom: base.device.stop
+! atoms: base.device.stop
+! legal: yes
+! observable: yes
+! ran_on_host: inside the compute region of interest (acc_on_device)
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: a STOP statement in device code that is not executed
+! 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 parallel loop copyin(a) copyout(b) copy(host_flag)
+  do i = 1, n
+    if (a(i) < 0) stop 1
+    b(i) = 2*a(i) + 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: an IF statement guarding STOP in device code: the STOP runs although its condition is false (target loop), or an
+! + internal compiler error (directly in a target region)
+! control: ../vendor/checks/src/cce/control/cce-acc-stop-in-compute-crash-control.f90 the IF with an assignment instead of STOP
+! same_as: catalog/cce-flang-stop-in-target-crash
+! end site

offload/_root/data/findings/catalog/cce-allocators-stack-ice.f90

@@ -0,0 +1,81 @@
+! # Draft finding: omp52-clause-uses_allocators on cce19
+!
+! - compiler: cce19
+! - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-uses_allocators (f90, version 52, sha256 52f8be7d9bfe1f86)
+! - expected: None (None; )
+! - actual: ice  (ice: INTERNAL COMPILER ERROR:  "Too few arguments on the stack" (/workspace/crayftn/pdgcs/v_fei.c, line 11730,
+!   version cc4d36e4ff3377d45f0e6e892b5dacd82009a0ca))
+! - 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-uses_allocators
+! primary atom: omp.clause.uses_allocators
+! 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_default_mem_alloc, 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 :: t
+  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(to: a) map(from: b) map(tofrom: host_flag) &
+  !$omp& uses_allocators(omp_default_mem_alloc)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    !$omp parallel do default(none) shared(a, b) private(t) allocate(omp_default_mem_alloc: t)
+      do i = 1, n
+        t = 2*a(i)
+        b(i) = t + 1
+      end do
+    !$omp end parallel do
+  !$omp end target
+  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: ftn: internal compiler error "Too few arguments on the stack" for uses_allocators with an allocate clause in a target
+! + region
+! control: ../vendor/checks/src/cce/control/cce-allocators-stack-ice-control.f90 the allocate and uses_allocators clauses removed
+! + (t private
+! + only)
+! end site
+! spec (requirement): uses_allocators makes a predefined allocator available for use in the region of the target
+!   construct.
+! "The uses_allocators clause enables the use of the specified allocator in the region associated with the directive
+!   on which the clause appears. If allocator refers to a predefined allocator, that predefined allocator will be
+!   available for use in the region." (5.2 §6.8 p.182 l.2-4)
+! spec (requirement): An allocate clause naming that allocator provides the storage for a list item that a
+!   data-sharing clause privatizes on the same directive.
+! "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): An allocator used in a target region by an allocate clause must appear in uses_allocators, as it
+!   does here.
+! "Memory allocators that do not appear in a uses_allocators clause cannot appear as an allocator in an allocate
+!   clause or be used in the target region" (5.2 §13.8 p.286 l.38-39)
+! spec (this program): uses_allocators(omp_default_mem_alloc) on target and allocate(omp_default_mem_alloc: t) with
+!   private(t) on the enclosed parallel do satisfy those rules; ftn stops with an internal error (Too few arguments on
+!   the stack).

offload/_root/data/findings/catalog/cce-atomic-default-mem-order-acquire-release-rejected.f90

@@ -0,0 +1,61 @@
+! # Draft finding: omp52-clause-atomic_default_mem_order-release on cce19
+!
+! - compiler: cce19
+! - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-atomic_default_mem_order-release (f90, version 52, sha256 4a88172afe9b3864)
+! - expected: None (None; )
+! - actual: rejected  (diagnostic: ftn-1725 ftn: ERROR GEN_PROG, File = ../../omp52-clause-atomic_default_mem_order-release.f90,
+!   Line = 13, Column = 50 | Unexpected syntax while parsing the DIRECTIVE statement : "(seq_cst |)
+! - 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-atomic_default_mem_order-release
+! primary atom: omp.clause.atomic_default_mem_order.release
+! legal: yes
+! observable: no (requires only changes semantics: no checked device effect)
+! 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
+  !$omp requires atomic_default_mem_order(release)
+  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 teams distribute parallel do map(to: a) map(from: b) map(tofrom: host_flag) &
+  !$omp& default(none) shared(a, b, host_flag)
+    do i = 1, n
+      b(i) = 2*a(i) + 1
+      if (i == 1) host_flag = merge(1, 0, omp_is_initial_device())
+    end do
+  !$omp end target teams distribute parallel do
+  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: craycc/ftn: OpenMP 5.1/5.2/6.0 forms HPE does not claim are rejected, and some crash the compiler instead of a diagnostic
+! control: ../vendor/checks/src/cce/control/cce-atomic-default-mem-order-acquire-release-rejected-control.f90
+! + atomic_default_mem_order(seq_cst)
+! + instead of (release)
+! same_as: catalog/cce-c-map-iterator-ice
+! end site

offload/_root/data/findings/catalog/cce-c-allocate-align-link.c

@@ -0,0 +1,83 @@
+// # Draft finding: omp52-c-clause-allocate-align on cce20
+//
+// - compiler: cce20
+// - toolchain: cce20; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-clause-allocate-align (c, version 52, sha256 f07c5cb195c9a71b)
+// - expected: None (None; )
+// - actual: rejected  (link_undefined_symbol: ld.lld: error: undefined symbol: __kmpc_aligned_alloc)
+// - 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 (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.c_gen (OpenMP 5.2, C11): the C port (offload.engine.f2c) of omp52-clause-allocate-align. Do not edit.
+// id: omp52-c-clause-allocate-align
+// primary atom: omp.clause.allocate.align
+// legal: yes
+// observable: no (unverified: the check covers the device kernel, not the atom)
+// ran_on_host: inside the target region of interest
+// evidence: unverified
+// needs: none
+// std: c11
+// unverified (oracle_not_written): the program does not check the private copy's address: a check of its address modulo an alignment larger than any default (e.g. align(4096)) would fail without the modifier (C mutant survived on AFAR)
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+enum { n = 64 };
+
+int main(void) {
+  int a[n];
+  int b[n];
+  int ref[n];
+  int host_flag;
+  bool ok;
+  int t;
+  for (int i = 1; i <= n; i++) {
+    a[i - 1] = i;
+    b[i - 1] = 0;
+    ref[i - 1] = 2 * i + 1;
+  }
+  host_flag = 1;
+  #pragma omp target map(to: a) map(from: b) map(tofrom: host_flag) \
+      uses_allocators(omp_default_mem_alloc)
+  {
+    host_flag = (omp_is_initial_device() ? 1 : 0);
+    #pragma omp parallel for default(none) shared(a, b) private(t) \
+        allocate(allocator(omp_default_mem_alloc), align(8): t)
+    for (int i = 1; i <= n; i++) {
+      t = 2 * a[i - 1];
+      b[i - 1] = t + 1;
+    }
+  }
+  bool t1_ = true;
+  for (int k2_ = 0; k2_ < n; k2_++)
+    t1_ = t1_ && (b[k2_] == ref[k2_]);
+  ok = t1_;
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: craycc: allocate(allocator(...), align(8): t) in a target region fails at the device link (__kmpc_aligned_alloc undefined)
+// control: ../vendor/checks/src/cce/control/cce-c-allocate-align-link-control.c allocate(omp_default_mem_alloc: t) without the
+// + align
+// + modifier
+// end site
+// spec (requirement): The allocate clause accepts the allocator and align modifiers with the syntax and semantics of
+//   the allocate directive's allocator and align clauses.
+// "The allocator-complex-modifier and align-modifier have the same syntax and semantics for the allocate clause as
+//   the allocator and align clauses have for the allocate directive." (5.2 §6.6 p.178 l.16-18)
+// spec (requirement): The align modifier makes every allocation at least as aligned as its value.
+// "each allocation is byte aligned to at least the maximum of the value to which alignment evaluates, the alignment
+//   trait of the allocator being used for the allocation, and the alignment required by the base language for the
+//   type of the variable that is allocated." (5.2 §6.3 p.175 l.3-6)
+// spec (requirement): On a target construct and in its region an allocate clause must name its allocator, which the
+//   program does, with uses_allocators for the predefined allocator.
+// "allocate clauses that appear on a target construct or on constructs in a target region must specify an
+//   allocator-simple-modifier or allocator-complex-modifier unless a requires directive with the dynamic_allocators
+//   clause is present in the same compilation unit." (5.2 §6.6 p.179 l.8-10)
+// spec (this program): allocate(allocator(omp_default_mem_alloc), align(8): t) on a parallel for in a target region
+//   is a legal allocate clause with both modifiers; craycc fails at the device link because __kmpc_aligned_alloc is
+//   undefined.

offload/_root/data/findings/catalog/cce-c-allocate-allocator-modifier-rejected.c

@@ -0,0 +1,77 @@
+// # Draft finding: omp52-c-clause-allocate-allocator on cce19
+//
+// - compiler: cce19
+// - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-clause-allocate-allocator (c, version 52, sha256 f3fb2637e316cfa9)
+// - expected: None (None; )
+// - actual: rejected  (diagnostic: <tmpdir>/omp52-c-clause-allocate-allocator.c:35:18: error: call to undeclared function 'allocator'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-dec)
+// - 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.c_gen (OpenMP 5.2, C11): the C port (offload.engine.f2c) of omp52-clause-allocate-allocator. Do not edit.
+// id: omp52-c-clause-allocate-allocator
+// primary atom: omp.clause.allocate.allocator
+// legal: yes
+// observable: no (unverified: the check covers the device kernel, not the atom)
+// ran_on_host: inside the target region of interest
+// evidence: unverified
+// needs: none
+// std: c11
+// unverified (needs_other_infrastructure): the program cannot observe which allocator provides the private copy of t (no OpenMP routine reports a variable's allocator; omp_default_mem_alloc and the default allocator both return ordinary memory; C mutant survived on AFAR)
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+enum { n = 64 };
+
+int main(void) {
+  int a[n];
+  int b[n];
+  int ref[n];
+  int host_flag;
+  bool ok;
+  int t;
+  for (int i = 1; i <= n; i++) {
+    a[i - 1] = i;
+    b[i - 1] = 0;
+    ref[i - 1] = 2 * i + 1;
+  }
+  host_flag = 1;
+  #pragma omp target map(to: a) map(from: b) map(tofrom: host_flag) \
+      uses_allocators(omp_default_mem_alloc)
+  {
+    host_flag = (omp_is_initial_device() ? 1 : 0);
+    #pragma omp parallel for default(none) shared(a, b) private(t) \
+        allocate(allocator(omp_default_mem_alloc): t)
+    for (int i = 1; i <= n; i++) {
+      t = 2 * a[i - 1];
+      b[i - 1] = t + 1;
+    }
+  }
+  bool t1_ = true;
+  for (int k2_ = 0; k2_ < n; k2_++)
+    t1_ = t1_ && (b[k2_] == ref[k2_]);
+  ok = t1_;
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// spec (requirement): The allocate clause of OpenMP 5.2 accepts the allocator-complex-modifier form allocator(...),
+//   with the syntax and semantics of the allocator clause.
+// "The allocator-complex-modifier and align-modifier have the same syntax and semantics for the allocate clause as
+//   the allocator and align clauses have for the allocate directive." (5.2 §6.6 p.178 l.16-18)
+// spec (requirement): The allocator clause names the memory allocator used for allocations associated with the
+//   construct.
+// "The allocator clause specifies the memory allocator to be used for allocations associated with the construct on
+//   which the clause appears." (5.2 §6.4 p.175 l.21-23)
+// spec (this program): allocate(allocator(omp_default_mem_alloc): t) uses the complex-modifier spelling; craycc reads
+//   allocator as a call to an undeclared function and rejects the clause, while the 5.0 spelling
+//   allocate(omp_default_mem_alloc: t) is accepted.
+// site:
+// title: craycc rejects the allocator modifier of the allocate clause
+// control: ../vendor/checks/src/cce/control/cce-c-allocate-allocator-modifier-rejected-control.c allocate(omp_default_mem_alloc:
+// + t), the 5.0 spelling
+// end site

offload/_root/data/findings/catalog/cce-c-device-type-directive-name-ice.c

@@ -0,0 +1,70 @@
+// # Draft finding: omp60-c-clause-device_type-directive_name on cce19
+//
+// - compiler: cce19
+// - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp60-c-clause-device_type-directive_name (c, version 60, sha256 fd0a4a751c810695)
+// - expected: None (None; )
+// - actual: ice  (ice: PLEASE submit a bug report to HPE at https://support.hpe.com/ and include the crash backtrace, preprocessed source, and associated run script.)
+// - 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.c_gen (OpenMP 6.0, C11): the C port (offload.engine.f2c) of omp60-clause-device_type-directive_name. Do not edit.
+// id: omp60-c-clause-device_type-directive_name
+// primary atom: omp.clause.device_type.directive_name
+// legal: yes
+// observable: no (f is implicitly declare target without the directive (a procedure referenced in a target construct, 5.2 §13.8 p.285, 6.0 §15.8 p.461), so the clause has no checked effect)
+// ran_on_host: inside the target region of interest
+// evidence: construct
+// needs: none
+// std: c11
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+enum { n = 64 };
+int dv = 1;
+int dw = 1;
+int f(int x) {
+  int r_;
+  r_ = 2 * x + 1;
+  return r_;
+}
+#pragma omp declare target enter(f) device_type(declare target: any)
+
+int main(void) {
+  int a[n];
+  int b[n];
+  int ref[n];
+  int host_flag;
+  bool ok;
+  for (int i = 1; i <= n; i++) {
+    a[i - 1] = i;
+    b[i - 1] = 0;
+    ref[i - 1] = 2 * i + 1;
+  }
+  host_flag = 1;
+  #pragma omp target map(to: a) map(from: b) map(tofrom: host_flag)
+  {
+    host_flag = (omp_is_initial_device() ? 1 : 0);
+    for (int i = 1; i <= n; i++) {
+      b[i - 1] = f(a[i - 1]);
+    }
+  }
+  bool t1_ = true;
+  for (int k2_ = 0; k2_ < n; k2_++)
+    t1_ = t1_ && (b[k2_] == ref[k2_]);
+  ok = t1_;
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: craycc/ftn: OpenMP 5.1/5.2/6.0 forms HPE does not claim are rejected, and some crash the compiler instead of a diagnostic
+// control: ../vendor/checks/src/cce/control/cce-c-device-type-directive-name-ice-control.c device_type(any) without the
+// + directive-name
+// + modifier
+// same_as: catalog/cce-c-map-iterator-ice
+// end site

offload/_root/data/findings/catalog/cce-c-dist-schedule-chunk.c

@@ -0,0 +1,81 @@
+// # Draft finding: omp52-c-clause-dist_schedule-chunk_size on cce19
+//
+// - compiler: cce19
+// - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-clause-dist_schedule-chunk_size (c, version 52, sha256 47094ef1ef5dfbfa)
+// - expected: check=pass (trusted; derivation + 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 (derivation + model): derivation + model agree; witnesses: afar/gfx942/unified, cce19/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size), cce20/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size), cce21/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size)
+// - 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/unified, cce19/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size), cce20/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size), cce21/gfx942/unified (port:omp52-clause-dist_schedule-chunk_size)
+// - withdrawn: none
+//
+// Generated by compliance.c_gen (OpenMP 5.2, C11): the C port (offload.engine.f2c) of omp52-clause-dist_schedule-chunk_size. Do not edit.
+// id: omp52-c-clause-dist_schedule-chunk_size
+// primary atom: omp.clause.dist_schedule.chunk_size
+// legal: yes
+// observable: yes
+// ran_on_host: inside the target region of interest
+// evidence: construct
+// needs: none
+// std: c11
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+
+enum { n = 64 };
+
+int main(void) {
+  int a[n];
+  int b[n];
+  int ref[n];
+  int host_flag;
+  bool ok;
+  int team[n];
+  int nt;
+  bool dok;
+  for (int i = 1; i <= n; i++) {
+    a[i - 1] = i;
+    b[i - 1] = 0;
+    ref[i - 1] = 2 * i + 1;
+  }
+  host_flag = 1;
+  for (int k1_ = 0; k1_ < n; k1_++)
+    team[k1_] = -1;
+  nt = -1;
+  #pragma omp target teams distribute parallel for map(to: a) map(from: b) map(from: team, nt) \
+      map(tofrom: host_flag) default(none) shared(a, b, team, nt, host_flag) num_teams(4) \
+      dist_schedule(static, 4)
+  for (int i = 1; i <= n; i++) {
+    b[i - 1] = 2 * a[i - 1] + 1;
+    team[i - 1] = omp_get_team_num();
+    if (i == 1) nt = omp_get_num_teams();
+    if (i == 1) host_flag = (omp_is_initial_device() ? 1 : 0);
+  }
+  dok = true;
+  for (int i = 1; i <= n; i++) {
+    dok = dok && (team[i - 1] == ((i - 1) / 4 % nt));
+  }
+  bool t2_ = true;
+  for (int k3_ = 0; k3_ < n; k3_++)
+    t2_ = t2_ && (b[k3_] == ref[k3_]);
+  ok = t2_ && (nt >= 1) && dok;
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: craycc: dist_schedule(static, 4) on target teams distribute parallel for puts every iteration on team 0
+// control: ../vendor/checks/src/cce/control/cce-c-dist-schedule-chunk-control.c num_teams(1) instead of num_teams(4) (every
+// + chunk on
+// + team 0)
+// end site
+// spec (requirement): With a chunk_size, dist_schedule divides the iterations into chunks of that size.
+// "If the chunk_size argument is specified, iterations are divided into chunks of size chunk_size." (5.2 §11.6.1
+//   p.256 l.18-19)
+// spec (requirement): The chunks are assigned to the initial teams of the league round-robin in team-number order.
+// "These chunks are assigned to the initial teams of the league in a round-robin fashion in the order of the initial
+//   team number." (5.2 §11.6.1 p.256 l.23-24)
+// spec (this program): dist_schedule(static, 4) with num_teams(4) puts iterations 1-4 on team 0, 5-8 on team 1, and
+//   so on, round robin; craycc places every iteration on team 0.

offload/_root/data/findings/catalog/cce-c-f-pointer-device-link.f90

@@ -0,0 +1,70 @@
+! # Draft finding: omp52-clause-is_device_ptr on cce19
+!
+! - compiler: cce19
+! - toolchain: cce19; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-is_device_ptr (f90, version 52, sha256 234487aa9ebe80a4)
+! - expected: None (None; )
+! - actual: rejected  (link_undefined_symbol: lld: error: undefined symbol: _C_F_POINTER)
+! - 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 (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-is_device_ptr
+! primary atom: omp.clause.is_device_ptr
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: copy_mode_only
+! needs: device_c_f_pointer
+! std: f2008
+! derivation (check=pass): target data maps a (to) and b (from); use_device_ptr(pa, pb) makes pa and pb the device addresses of a
+! derivation: and b (5.2 §5.4.8 p.121); the nested target has is_device_ptr(pa, pb), so they are used as device pointers there (5.2
+! derivation: §5.4.7 p.120) and qq(i) = 2*pp(i) + 1 writes the device's b; the end of target data copies b back: b = ref; the check
+! derivation: accepts
+program gen_prog
+  use omp_lib, only: omp_is_initial_device
+  use, intrinsic :: iso_c_binding, only: c_ptr, c_loc, c_f_pointer
+  implicit none
+  integer, parameter :: n = 64
+  integer, allocatable, target :: a(:), b(:)
+  integer :: ref(n)
+  integer :: i, host_flag
+  logical :: ok
+  type(c_ptr) :: pa, pb
+  integer, pointer :: pp(:), qq(:)
+  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
+  pa = c_loc(a)
+  pb = c_loc(b)
+  !$omp target data map(to: a) map(from: b) use_device_ptr(pa, pb)
+    !$omp target is_device_ptr(pa, pb) private(pp, qq) map(tofrom: host_flag)
+      host_flag = merge(1, 0, omp_is_initial_device())
+      call c_f_pointer(pa, pp, [n])
+      call c_f_pointer(pb, qq, [n])
+      do i = 1, n
+        qq(i) = 2*pp(i) + 1
+      end do
+    !$omp end target
+  !$omp end target data
+  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: ftn: C_F_POINTER called in a target region fails at the device link (_C_F_POINTER undefined)
+! control: ../vendor/checks/src/cce/control/cce-c-f-pointer-device-link-control.f90 the device loop reads a and writes b directly
+! + instead of
+! + through c_f_pointer
+! end site