offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/apps/gcc-acc-tile-partial-tiles-wrong.f90

@@ -0,0 +1,64 @@
+! # Finding (GCC 16.2, application corpus): OpenACC tile(32, 32) over loops whose trip counts are not multiples of 32 computes
+!   wrong elements
+!
+! - toolchains: gcc_g90 (GCC 16.2.0, AMD Instinct MI250X gfx90a, Tioga) and gcc_sm80 (GCC 16.2.0, NVIDIA A100 sm_80, wingtip);
+!   separate memory only; -O2
+! - build: gfortran -fopenacc -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90);
+!   -foffload=nvptx-none -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+! - failure: wrong_answer
+! - observed: `bad= 4342` (of the 10000 elements checked) and check=fail in every run (gcc_sm80: mandatory wrong 5 of 5; unset wrong
+!   5 of 5; gcc_g90: mandatory wrong 5 of 5; unset wrong 5 of 5 (results/parity/<machine>/<tc>/probes.jsonl))
+! - expected: `bad= 0`, then `RESULT ran_on_host=0 check=pass`
+! - rule: "Each loop in the nest will be split, or strip-mined, into two loops, an outer tile loop and an inner element loop. The
+!   trip count of the element loop will be limited to the corresponding tile size from the size-expr-list" (OpenACC 3.4 §2.9.8
+!   l.2486-2489): tiling reorders the iterations of the nest, each still runs once. The tile clause is OpenACC 2.0's; GCC documents
+!   OpenACC 2.6.
+! - same-compiler control (correct, gcc_sm80: mandatory pass 5 of 5; unset pass 5 of 5; gcc_g90: mandatory pass 5 of 5; unset pass 5
+!   of 5 (results/parity/<machine>/<tc>/probes.jsonl)): collapse(2) in place of tile(32, 32) (controls/gcc-acc-tile-control.f90).
+!   With trip counts of 64 (multiples of the tile size) the tiled form is correct too, and so is a one-loop tile(32) (C and Fortran,
+!   both GPUs, mandatory pass 5 of 5, unset pass 5 of 5; results/parity/probes-r2/tile_mult32.*, tile_one_loop.*).
+! - application: prk-f-stencil-acc (FORTRAN/stencil-openacc.F90) of the Parallel Research Kernels
+!   (data/bench/apps/manifest.yaml): its
+!   stencil kernels are `acc parallel loop tile(*,*)` over the interior of a 1000 x 1000 grid; GCC's run prints `ERROR: L1 norm =
+!   22.634350 Reference L1 norm = 22.000000` on both GPUs (results/parity/<machine>/results/apps/runs). NVHPC 25.11 and 26.9
+!   validate it (results/apps/wingtip/runs).
+! - other families: NVHPC 25.11 and 26.9 run this file correctly in both memory modes, CCE 19/20/21/21.0.4 too (Fortran OpenACC)
+!   (site matrix). The site's finding matrix runs this file on every compiler.
+! - legality: OpenACC 3.4 §2.9.8; the nest is tightly nested and every iteration writes its own element (no race). GCC is a compiler
+!   under test only and never a legality witness.
+program tile_partial
+  use openacc, only: acc_device_host, acc_on_device
+  implicit none
+  integer, parameter :: n = 100
+  integer :: a(n, n)
+  integer :: i, j, bad, want, host_flag
+  a = 0
+  !$acc parallel loop tile(32, 32) copy(a)
+  do j = 2, n - 1
+    do i = 2, n - 1
+      a(i, j) = a(i, j) + i + j
+    end do
+  end do
+  host_flag = 1
+  !$acc parallel num_gangs(1) copy(host_flag)
+  if (.not. acc_on_device(acc_device_host)) host_flag = 0
+  !$acc end parallel
+  bad = 0
+  do j = 1, n
+    do i = 1, n
+      want = 0
+      if (i > 1 .and. i < n .and. j > 1 .and. j < n) want = i + j
+      if (a(i, j) /= want) bad = bad + 1
+    end do
+  end do
+  print '(a,i0)', 'bad= ', bad
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', bad == 0)
+end program tile_partial
+! site:
+! title: OpenACC tile(32, 32) over loops whose trip counts are not multiples of the tile size computes wrong elements
+! summary: A parallel loop tile(32, 32) over a 98 x 98 (or 100 x 100) nest should run every iteration once. GCC 16.2 leaves 4342 of
+! + the 10000 elements it checks wrong (C and Fortran), on the MI250X and the A100. The same nest with collapse(2), or with trip
+! + counts that are multiples of 32, is correct. Found through the Parallel Research Kernels' OpenACC stencil.
+! control: apps/controls/gcc-acc-tile-control.f90 collapse(2) in place of tile(32, 32)
+! same_as: apps/gcc-acc-c-tile-partial-tiles-wrong
+! end site

offload/_root/data/findings/catalog/afar-c-complex-reduction-link.c

@@ -0,0 +1,66 @@
+// # WITHDRAWN : not a compiler defect. The undefined
+// # __atomic_load / __atomic_compare_exchange come from the HOST object (the program
+// # without the target construct fails the same way); with -latomic it builds and passes on
+// # the device in both memory modes (vendor, case afar-c-complex-reduction-latomic).
+// # The build recipe does not link libatomic: ours. Kept as a record; not in index.yaml;
+// # the confirmer decides its cells our_bug (catalog/rulings.yaml RUL-HOST-LIBATOMIC).
+//
+// # Draft finding: omp52-c-w-reduction-complex on afar
+//
+// - compiler: afar
+// - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-w-reduction-complex (c, version 52, sha256 30455f14bdeff947)
+// - expected: None (None; )
+// - actual: rejected  (link_undefined_symbol: ld.lld: error: undefined symbol: __atomic_load)
+// - 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); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+//   here) compile it; the check's other witness, the AFAR clang 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, C11; catalog widening). Do not edit.
+// id: omp52-c-w-reduction-complex
+// primary atom: pair.omp.clause.reduction+base.device.complex
+// atoms: pair.omp.clause.reduction+base.device.complex, omp.clause.reduction, base.device.complex
+// legal: yes
+// observable: yes
+// ran_on_host: inside the target region of interest
+// evidence: construct
+// needs: none
+// std: c11
+// feature: a double _Complex sum reduction
+// spec: the parts' own programs
+// pair of: omp.clause.reduction + base.device.complex (each has a program of its own)
+#include <stdio.h>
+#include <stdbool.h>
+#include <omp.h>
+#include <complex.h>
+
+enum { n = 64 };
+
+int main(void) {
+  int a[n], b[n], ref[n];
+  int host_flag = 1;
+  double _Complex z = 0;
+  for (int i = 0; i < n; i++) {
+    a[i] = i + 1;
+    b[i] = 0;
+    ref[i] = 0;
+  }
+  #pragma omp target teams distribute parallel for map(to: a) map(tofrom: host_flag) \
+      reduction(+: z)
+  for (int i = 0; i < n; i++) {
+    z += (double)a[i] - (double)a[i] * I;
+    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]);
+  ok = ok && (creal(z) == n * (n + 1) / 2.0 && cimag(z) == -n * (n + 1) / 2.0);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}

offload/_root/data/findings/catalog/afar-c-critical-hint-link.c

@@ -0,0 +1,68 @@
+// # Draft finding: omp52-c-w-critical-hint on afar
+//
+// - compiler: afar
+// - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-w-critical-hint (c, version 52, sha256 27f075f0e726545a)
+// - 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 (NVC++-F-1196-OpenMP - omp critical is not supported in GPU region);
+//   the check's other witness, the AFAR clang 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, C11; catalog widening). Do not edit.
+// id: omp52-c-w-critical-hint
+// primary atom: omp.clause.hint
+// atoms: omp.clause.hint
+// legal: yes
+// observable: yes
+// ran_on_host: inside the target region of interest
+// evidence: construct
+// needs: none
+// std: c11
+// feature: a named critical construct with a hint clause 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; §15.1 (hint clause)
+#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 s = 0;
+  for (int i = 0; i < n; i++) {
+    a[i] = i + 1;
+    b[i] = 0;
+    ref[i] = 0;
+  }
+  #pragma omp target parallel for map(to: a) map(tofrom: s, host_flag)
+  for (int i = 0; i < n; i++) {
+    #pragma omp critical(wsum) hint(omp_sync_hint_contended)
+    {
+      int t = s;
+      s = t + a[i];
+    }
+    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]);
+  ok = ok && (s == n * (n + 1) / 2);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// 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-c-critical-hint-link-control.c the hint clause removed (a named critical
+// + without hint)
+// same_as: catalog/afar-flang-named-critical-link
+// end site

offload/_root/data/findings/catalog/afar-c-ordered-doacross-link.c

@@ -0,0 +1,62 @@
+// # Draft finding: omp52-c-clause-ordered-n on afar
+//
+// - compiler: afar
+// - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-clause-ordered-n (c, version 52, sha256 872526bfa6d022e4)
+// - expected: None (None; )
+// - actual: rejected  (link_undefined_symbol: ld.lld: error: undefined symbol: __kmpc_doacross_init)
+// - 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-ordered-n. Do not edit.
+// id: omp52-c-clause-ordered-n
+// primary atom: omp.clause.ordered.n
+// legal: yes
+// observable: no (equivalent_default: the check covers the device kernel, not the atom)
+// ran_on_host: inside the target region of interest
+// evidence: equivalent_default
+// needs: none
+// std: c11
+// no oracle (equivalent_default): re-categorised (was implementation_defined): without n the ordered clause behaves as if n were the collapse value, here 1, so ordered(1) on this one-loop nest is the ordered clause without its argument, with or without doacross constructs
+// basis: OpenMP 5.2 §4.4.4, p.94: "If n is not specified then the behavior is as if n is specified with the same value as is specified for the collapse clause on the construct."
+#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;
+  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);
+    #pragma omp parallel for default(none) shared(a, b) ordered(1)
+    for (int i = 1; i <= n; i++) {
+      b[i - 1] = 2 * a[i - 1] + 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: amdclang: ordered(1) on a parallel for in a target region fails at the device link (__kmpc_doacross_init undefined)
+// control: ../vendor/checks/src/afar/control/afar-c-ordered-doacross-link-control.c the ordered(1) clause removed
+// end site

offload/_root/data/findings/catalog/afar-c-reduction-task-link.c

@@ -0,0 +1,81 @@
+// # Draft finding: omp52-c-clause-reduction-task on afar
+//
+// - compiler: afar
+// - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+// - program: catalog omp52-c-clause-reduction-task (c, version 52, sha256 54be3b72d697c751)
+// - expected: None (None; )
+// - actual: rejected  (link_undefined_symbol: ld.lld: error: undefined symbol: __kmpc_taskred_modifier_init)
+// - 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-reduction-task. Do not edit.
+// id: omp52-c-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: 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 s;
+  int sref;
+  for (int i = 1; i <= n; i++) {
+    a[i - 1] = i;
+    b[i - 1] = 0;
+    ref[i - 1] = 2 * i + 1;
+  }
+  host_flag = 1;
+  s = 0;
+  sref = 0;
+  for (int i = 1; i <= n; i++) {
+    sref = sref + a[i - 1];
+  }
+  #pragma omp target map(to: a) map(from: b) map(tofrom: host_flag) map(tofrom: s)
+  {
+    host_flag = (omp_is_initial_device() ? 1 : 0);
+    #pragma omp parallel default(none) shared(a, b, s)
+    {
+      #pragma omp for reduction(task, +: s)
+      for (int i = 1; i <= n; i++) {
+        b[i - 1] = 2 * a[i - 1] + 1;
+        s = s + a[i - 1];
+      }
+    }
+  }
+  bool t1_ = true;
+  for (int k2_ = 0; k2_ < n; k2_++)
+    t1_ = t1_ && (b[k2_] == ref[k2_]);
+  ok = t1_ && (s == sref);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: amdclang: reduction(task, +: s) on a worksharing loop in a target region fails at the device link
+// + (__kmpc_taskred_modifier_init undefined)
+// control: ../vendor/checks/src/afar/control/afar-c-reduction-task-link-control.c reduction(+: s) without the task modifier
+// end site
+// spec (requirement): The task reduction-modifier on a reduction clause of a parallel or worksharing construct
+//   privatizes the list item and supports task reductions.
+// "If the task reduction-modifier is present for a parallel or worksharing construct, then each list item is
+//   privatized according to the description and restrictions in Section 5.3" (5.2 §5.5.8 p.135 l.16-18)
+// spec (requirement): After the region the original list item contains the result of the reduction.
+// "After the end of the region, the original list item contains the result of the reduction." (5.2 §5.5.8 p.135
+//   l.21-22)
+// spec (this program): reduction(task, +: s) on a worksharing loop inside a parallel region in a target region must
+//   leave the sum of a in s; amdclang fails at the device link (__kmpc_taskred_modifier_init undefined).

offload/_root/data/findings/catalog/afar-flang-absent-optional-target-crash.f90

@@ -0,0 +1,76 @@
+! # Draft finding: omp52-w-optional-absent on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-w-optional-absent (f90, version 52, sha256 a951b1f34bd1c3af)
+! - expected: check=pass (trusted; elision + model)
+! - actual: crash  (crash: SIGABRT; without mandatory: 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:
+!   cce19/gfx942/unified, cce20/gfx942/unified, cce21/gfx942/unified, 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.rules accepts it (offload.engine.prerun.check, rerun: with the
+!   race rule and the restriction checks); nvfortran/nvc 26.9 and 25.11 (NVHPC, not under test
+!   here) compile it; 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: cce19/gfx942/unified, cce20/gfx942/unified, cce21/gfx942/unified, elision
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenMP 5.2, free-form Fortran; catalog widening). Do not edit.
+! id: omp52-w-optional-absent
+! primary atom: base.device.optional_absent
+! atoms: base.device.optional_absent
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: an absent OPTIONAL dummy array referenced with PRESENT() in a target region of the procedure
+! spec: OpenMP 5.2 §3.2.1, p.61: a list item that is an absent optional dummy is ignored, and the data-sharing and data-mapping
+! rules of an absent optional referenced in a construct are ignored
+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
+  call work(a, b, host_flag)
+  ok = all(b == ref)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+contains
+  subroutine work(x, y, hf, c)
+    integer, intent(in) :: x(n)
+    integer, intent(inout) :: y(n)
+    integer, intent(inout) :: hf
+    integer, intent(in), optional :: c(n)
+    integer :: k
+    !$omp target teams distribute parallel do map(to: x) map(tofrom: y, hf)
+    do k = 1, n
+      if (present(c)) then
+        y(k) = x(k) + c(k)
+      else
+        y(k) = 2*x(k) + 1
+      end if
+      if (k == 1) hf = merge(1, 0, omp_is_initial_device())
+    end do
+    !$omp end target teams distribute parallel do
+  end subroutine work
+end program wide_prog
+! site:
+! title: amdflang: an absent OPTIONAL dummy array referenced with PRESENT() in a target region crashes the run
+! control: ../vendor/checks/src/afar/control/afar-flang-absent-optional-target-crash-control.f90 the PRESENT(c) branch removed (the
+! + absent dummy
+! + is not referenced in the region)
+! end site

offload/_root/data/findings/catalog/afar-flang-critical-target-parallel-wrong.f90

@@ -0,0 +1,74 @@
+! # Draft finding: omp52-w-critical on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-w-critical (f90, version 52, sha256 7f0f6d194e31f04f)
+! - 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 (CCE ICEs, NVHPC
+!   rejects), so the mutant cannot be credited (unaudited, not weak); the C port's identical check is valid (its mutant killed on
+!   AFAR), and the mutant fails only by a race (a device effect)
+! - 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-w-critical), afar/gfx942/unified (port:omp52-c-w-critical), cce19/gfx942/copy (port:omp52-c-w-critical), cc ...
+! - 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.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: afar/gfx942/copy (port:omp52-c-w-critical), afar/gfx942/unified (port:omp52-c-w-critical), cce19/gfx942/copy
+!   (port:omp52-c-w-critical), cce19/gfx942/unified (port:omp52-c-w-critical), cce20/gfx942/copy (port:omp52-c-w-critical),
+!   cce20/gfx94 ...
+! - withdrawn: none
+!
+! Generated by compliance.widen (OpenMP 5.2, free-form Fortran; catalog widening). Do not edit.
+! id: omp52-w-critical
+! primary atom: omp.directive.critical
+! atoms: omp.directive.critical
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+! feature: an unnamed 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
+    t = s
+    s = t + a(i)
+    !$omp end critical
+    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: an unnamed critical in a target parallel do does not exclude other threads (lost updates)
+! control: ../vendor/checks/src/afar/control/afar-flang-critical-target-parallel-wrong-control.f90 an atomic update instead of
+! + the critical
+! + construct
+! end site

offload/_root/data/findings/catalog/afar-flang-dist-schedule-chunk.f90

@@ -0,0 +1,80 @@
+! # Draft finding: omp52-clause-dist_schedule-chunk_size on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-dist_schedule-chunk_size (f90, version 52, sha256 3628c7a53985f9c2)
+! - expected: check=pass (trusted; derivation + model + probe)
+! - 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 + probe): stored main verdict: derivation + model + probe agree;
+!   witnesses: afar/gfx942/copy (port:omp52-c-clause-dist_schedule-chunk_size), afar/gfx942/unified
+!   (port:omp52-c-clause-dist_schedule-chunk_size), cce19/gfx942/copy, cce19/gfx942/unified, cce20/gfx942/copy,
+!   cce20/gfx942/unified, cce21/gfx942/copy, cce21/gfx942/unified
+! - 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-dist_schedule-chunk_size), afar/gfx942/unified
+!   (port:omp52-c-clause-dist_schedule-chunk_size), cce19/gfx942/copy, cce19/gfx942/unified, cce20/gfx942/copy,
+!   cce20/gfx942/unified, cce21/gfx942/copy, cce21/gfx942/unified
+! - withdrawn: none
+!
+! Generated by compliance.gen (OpenMP 5.2, free-form Fortran). Do not edit.
+! id: omp52-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: f2008
+! derivation (check=pass): dist_schedule(static, 4): chunks of 4 iterations assigned to the initial teams round-robin in team-number
+! derivation: order (5.2 §11.6.1 p.256), so iteration i runs on team mod((i - 1)/4, nt), which dok tests; nt >= 1 and b = ref; the
+! derivation: check accepts
+program gen_prog
+  use omp_lib, only: omp_get_num_teams, omp_get_team_num, 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 :: team(n), nt
+  logical :: dok
+  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
+  team = -1
+  nt = -1
+  !$omp target teams distribute parallel do map(to: a) map(from: b) map(from: team, nt) &
+  !$omp& map(tofrom: host_flag) default(none) shared(a, b, team, nt, host_flag) num_teams(4) &
+  !$omp& dist_schedule(static, 4)
+    do i = 1, n
+      b(i) = 2*a(i) + 1
+      team(i) = omp_get_team_num()
+      if (i == 1) nt = omp_get_num_teams()
+      if (i == 1) host_flag = merge(1, 0, omp_is_initial_device())
+    end do
+  !$omp end target teams distribute parallel do
+  dok = .true.
+  do i = 1, n
+    dok = dok .and. team(i) == mod((i - 1)/4, nt)
+  end do
+  ok = all(b == ref) .and. (nt >= 1) .and. dok
+  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: dist_schedule(static, 4) is not applied: 64 iterations over 4 teams go to teams 0 and 1 in two blocks of 32
+! control: ../vendor/checks/src/afar/control/afar-flang-dist-schedule-chunk-control.f90 num_teams(1) instead of num_teams(4)
+! + (every chunk
+! + on team
+! + 0)
+! end site

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

@@ -0,0 +1,68 @@
+! # Draft finding: omp52-clause-linear on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: unified; opt: -O2
+! - program: catalog omp52-clause-linear (f90, version 52, sha256 707ffe408d371cb3)
+! - 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 5.2, free-form Fortran). Do not edit.
+! id: omp52-clause-linear
+! primary atom: omp.clause.linear
+! legal: yes
+! observable: yes
+! ran_on_host: inside the target region of interest
+! evidence: construct
+! needs: none
+! std: f2008
+! derivation (check=pass): linear(x: 1) on the parallel do (5.2 §5.4.6 p.118): on the logical iteration of i (number i - 1) the new
+! derivation: x is the original x (3) plus (i - 1)*1, so x - (i + 2) = 0 and b(i) = 2*a(i) + 1 = 2*i + 1 = ref(i); the body's x = x
+! derivation: + 1 keeps x on that sequence, and the value of the sequentially last iteration, taken as the new x at the end of that
+! derivation: iteration (3 + n after its increment, as the OpenMP Examples' linear programs assume), is assigned to the original x,
+! derivation: which the target maps tofrom: x = 1*n + 3; the check accepts
+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 :: x
+  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
+  x = 3
+  !$omp target map(to: a) map(from: b) map(tofrom: x) map(tofrom: host_flag)
+    host_flag = merge(1, 0, omp_is_initial_device())
+    !$omp parallel do default(none) shared(a, b) linear(x: 1)
+      do i = 1, n
+        b(i) = 2*a(i) + 1 + (x - (1*i + 2))
+        x = x + 1
+      end do
+    !$omp end parallel do
+  !$omp end target
+  ok = all(b == ref) .and. (x == 1*n + 3)
+  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: compiler crash in OpenMPIRBuilder::createParallel for linear on a parallel do in a target region
+! control: ../vendor/checks/src/afar/control/afar-flang-linear-parallel-ice-control.f90 the same parallel do on the host (the target
+! + directive
+! + removed)
+! end site