offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/harvest/gcc-teams-simd-matmul-allocatable-ice.f90

@@ -0,0 +1,53 @@
+! # Finding (GCC 16.2, LLVM/AOMP harvest): matmul of allocatable array sections in target teams distribute parallel do simd:
+!   internal compiler error in gfc_omp_clause_default_ctor
+!
+! - 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 -fopenmp -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: ice: internal compiler error: in gfc_omp_clause_default_ctor
+! - observed: `internal compiler error: in gfc_omp_clause_default_ctor, at fortran/trans-openmp.cc:840` at the combined directive,
+!   on both targets (the host compiler fails before any offload code is made)
+! - expected: compiles; prints `sum=   6720.0` and `RESULT ran_on_host=0 check=pass`
+! - rule: a simd construct may contain calls ("The only OpenMP constructs that can be encountered during execution of a simd region
+!   are ..." restricts OpenMP constructs, not procedure references: 5.2 §17.1 p.338 l.25-27); matmul is an intrinsic function of the
+!   base language (Fortran 2018 16.9.124).
+! - same-compiler control (compiles; 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)): the product as explicit loops in the same construct
+!   (controls/gcc-teams-simd-matmul-allocatable-control.f90). With explicit-shape arrays the matmul form compiles and runs correctly
+!   on both GPUs (mandatory pass 5 of 5; unset pass 5 of 5; results/parity/probes-r2/matmul_explicit.f90). Without simd it compiles;
+!   it runs correctly on the MI250X (5 of 5), and on the A100 the offload image fails to load (`libgomp: Link error log error :
+!   Prototype doesn't match for '_gfortran_matmul_r4'`, exit 1, 5 of 5; results/parity/probes-r2/matmul_nosimd.f90): a lead, not
+!   part of this finding.
+! - other families: AFAR and NVHPC 25.11/26.9 run the harvested program correctly (results/harvest/main); CCE fails it another way.
+!   The site's finding matrix runs this file on every compiler.
+! - harvested programs (2 cells (1 gcc_g90, 1 gcc_sm80); gate: confirmed 2; confirmer: compiler_bug (R10-compile-ice) 2):
+!   hv-aomp-smoke-fails-flang-324387
+! - legality: the pre-run check (offload.engine.prerun.check: the rules and AFAR's front end, two witnesses) accepts the harvested
+!   program; GCC is a compiler under test only and never a legality witness.
+program matmul_teams_simd
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer :: k, host_flag
+  real, allocatable :: a(:,:,:), b(:,:,:), c(:,:,:)
+  allocate(a(5,7,16), b(7,6,16), c(5,6,16))
+  a = 1.0
+  b = 2.0
+  c = 0.0
+  host_flag = 1
+  !$omp target teams distribute parallel do simd map(tofrom: a, b, c, host_flag)
+  do k = 1, 16
+    if (k == 1) host_flag = merge(1, 0, omp_is_initial_device())
+    c(:,:,k) = c(:,:,k) + matmul(a(:,:,k), b(:,:,k))
+  end do
+  ! every element is 7 * (1.0 * 2.0)
+  print '(a,f8.1)', 'sum= ', sum(c)
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', sum(c) == 5*6*16*14.0)
+end program matmul_teams_simd
+! site:
+! title: matmul of allocatable array sections in target teams distribute parallel do simd: internal compiler error
+! summary: A target teams distribute parallel do simd loop whose body assigns matmul of sections of allocatable arrays stops
+! + GCC 16.2's Fortran front end with an internal compiler error (gfc_omp_clause_default_ctor), for both offload targets. The
+! + same loop with the product written as loops compiles and runs correctly. AFAR and NVHPC run the harvested program correctly.
+! control: harvest/controls/gcc-teams-simd-matmul-allocatable-control.f90 the product written as explicit loops
+! end site

offload/_root/data/findings/harvest/nvhpc-c-target-data-if-false-use-device-ptr-garbage.c

@@ -0,0 +1,49 @@
+// # Finding (known-issues harvest): NVHPC gives use_device_ptr a garbage pointer
+//   when the target data construct's if clause is false
+//
+// - source: UoB-HPC/TeaLeaf commit c35c0e57f6 (pack_halos.cpp: "#pragma omp target data if
+//   (!settings.staging_buffer && settings.is_offload) use_device_ptr(...)", hoisted for an AOMP
+//   bug, aomp#601); data/bench/harvest-known hk-018. The conjunction is not the trigger here: the
+//   literal if(0) fails the same way (data/reports/harvest-known/v018-data-if-false.c is the
+//   struct-member form)
+// - compilers: NVHPC nvc 25.11 and 26.9, -mp=gpu -gpu=cc80 (separate and managed memory)
+// - expected: seen == the host address of buf, RESULT ... check=pass. "When an if clause is
+//   present and the if clause expression evaluates to false, the target device is the host"
+//   (OpenMP 5.2 §13.5 p.279 l.12-13); on the host device buf's corresponding storage is buf
+//   itself, so the use_device_ptr conversion refers to the host address (§5.4.8 p.121 l.15-21)
+// - actual: p inside the region is 0xc (both releases, both memory modes; "host 0x7ffe... seen
+//   0xc"), RESULT ... check=fail
+// - control (same compiler): with the if clause true the region sees the device address that
+//   omp_get_mapped_ptr returns (data/reports/harvest-known/c018-data-if-true.c); TeaLeaf's other
+//   use, target update if(<conjunction>), behaves (v018-update-if.c)
+// - other families: AFAR and CCE 19/20/21 give the host address (gfx90a and gfx942)
+// - legality: buf is mapped by target enter data before the construct and p points to it
+//   (§5.4.8 p.121 l.15-18); the if clause takes any scalar expression; the pre-run check
+//   (rules and the AFAR front end) accepts the program
+// - evidence: results/harvest-known/main.wingtip (hk-018, gate: confirmed), results/harvest-known/probes.wingtip.jsonl,
+//   the MI250X probe runs' output for AFAR and CCE (results/harvest-known/logs/tioga/probe.f656gDkdAd9R.log; its rows
+//   file probes.tioga.jsonl was not kept)
+#include <omp.h>
+#include <stdbool.h>
+#include <stdio.h>
+struct settings { bool staging_buffer; bool is_offload; };
+int main(void) {
+  enum { N = 512 };
+  double buf[N];
+  double *p = buf, *seen = NULL;
+  struct settings s = {true, true};
+#pragma omp target enter data map(to: buf[:N])
+#pragma omp target data if (0) use_device_ptr(p)
+  { seen = p; }
+  printf("host %p seen %p\n", (void *)buf, (void *)seen);
+  int ok = (seen == buf);
+#pragma omp target exit data map(delete: buf[:N])
+  int hk_host = 1;
+#pragma omp target map(tofrom: hk_host)
+  hk_host = omp_is_initial_device();
+  printf("RESULT ran_on_host=%d check=%s\n", hk_host, ok ? "pass" : "fail");
+  return 0;
+}
+// site:
+// title: nvc: use_device_ptr gives a garbage pointer when the if clause of target data is false
+// end site

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

@@ -0,0 +1,65 @@
+! # Finding (known-issues harvest): NVHPC rejects a module's named-constant array
+!   referenced in an OpenMP declare target routine
+!
+! - source: holdout (a case of the known-issues harvest, held out); this file is the
+!   minimal form (data/reports/harvest-known/v-param-array-routine.f90)
+! - compilers: NVHPC nvfortran 25.11 and 26.9, -mp=gpu -gpu=cc80 (separate and managed memory)
+! - expected: the program compiles and prints RESULT ... check=pass: pick returns c(i), a
+!   module named constant [1.5, 2.5]
+! - actual: "NVFORTRAN-S-1079-Module variables used in omp target routine need to be in omp
+!   declare target() - c$ac" (the named constant read as a module variable), both releases,
+!   both memory modes
+! - control (same compiler): passes with a scalar named constant in the routine
+!   (c-param-scalar-routine.f90), with the array a named constant of the routine itself
+!   (c-param-array-local.f90), and with the array indexed in the target region itself
+!   (c-param-array-region-only.f90); all in data/reports/harvest-known/
+! - other families: AFAR compiles and runs it (check=pass); CCE 19/20/21 reject it too
+!   (harvest/cce-named-constant-array-declare-target-routine-rejected.f90)
+! - legality: Fortran named constants are not variables; OpenMP 5.2's declare target
+!   requirement covers variables only: "A variable referenced in a target region but not the
+!   target construct that is not declared in the target region must appear in a declare target
+!   directive" (§13.8 p.286 l.31-32), and named constants are predetermined shared (§5.1.1 p.98
+!   l.11: "Assumed-size arrays and named constants are shared"); a named constant is a list
+!   item only "in clauses where it is explicitly allowed" (§3.2.1 p.61 l.10), and declare
+!   target's clauses do not name it. The pre-run check (rules and the AFAR front end) accepts the
+!   program
+! - the OpenACC form (routine seq; hk-015) compiles and runs on NVHPC
+! - MFC's documented nvfortran 23.11/24.1 fort2 crash on a parameter array passed into a
+!   declare-target routine (hk-005) no longer reproduces: hk-005 compiles and runs on 25.11/26.9
+! - evidence: results/harvest-known/main.wingtip (gate: confirmed), results/harvest-known/probes.wingtip.jsonl
+module vpa_m
+  implicit none
+  real(8), parameter :: c(2) = [1.5d0, 2.5d0]
+contains
+  subroutine pick(i, x)
+    !$omp declare target
+    integer, intent(in) :: i
+    real(8), intent(out) :: x
+    x = c(i)
+  end subroutine pick
+end module vpa_m
+
+program vpa
+  use omp_lib
+  use vpa_m
+  implicit none
+  integer :: k, bad, hk_host
+  real(8) :: r(100)
+  r = 0
+  !$omp target teams distribute parallel do map(from: r)
+  do k = 1, 100
+    call pick(1 + mod(k, 2), r(k))
+  end do
+  bad = 0
+  do k = 1, 100
+    if (r(k) /= c(1 + mod(k, 2))) bad = bad + 1
+  end do
+  hk_host = 1
+  !$omp target map(tofrom: hk_host)
+  if (.not. omp_is_initial_device()) hk_host = 0
+  !$omp end target
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', hk_host, ' check=', merge('pass', 'fail', bad == 0)
+end program vpa
+! site:
+! title: nvfortran rejects a module's named-constant array referenced in a declare target routine
+! end site

offload/_root/data/findings/harvest/nvhpc-use-device-ptr-c-ptr-not-found.f90

@@ -0,0 +1,60 @@
+! # Finding (known-issues harvest): NVHPC aborts on use_device_ptr of a C_PTR
+!   that points to mapped data ("data in use_device clause was not found")
+!
+! - source: the NVIDIA forum topic 290317 (nvfortran dropping use_device_addr on an allocatable,
+!   TPR 36867; that defect is gone in 25.11 and 26.9) gave data/bench/harvest-known hk-040; this file is
+!   its use_device_ptr half (data/reports/harvest-known/v040-ptr-print.f90)
+! - compilers: NVHPC nvfortran 25.11 and 26.9, -mp=gpu -gpu=cc80 (separate and managed memory)
+! - expected: seen equals mapped (the device address of tab), RESULT ... check=pass
+! - actual: the run stops at the target data construct, exit status 1: "FATAL ERROR: data in
+!   use_device clause was not found on device 1: host:0x4197a8", a static address (cp's own
+!   storage; tab is on the heap, the present table lists it at host:0x1f173160), both releases,
+!   both memory modes, with and without OMP_TARGET_OFFLOAD=mandatory. The compiler also warns
+!   "Use of the USE_DEVICE_PTR clause is deprecated" for this C_PTR list item
+! - control (same compiler): use_device_addr(tab) on the allocatable gives the mapped address
+!   (data/reports/harvest-known/v040-addr.f90, check=pass); the C form, use_device_ptr of a C
+!   pointer, converts correctly (data/reports/harvest-known/c018-data-if-true.c)
+! - other families: AFAR converts it (seen = mapped); CCE 19/20/21 leave the host address
+!   (harvest/cce-use-device-ptr-c-ptr-not-converted.f90)
+!   This file uses omp_get_mapped_ptr as the reference: AFAR at HSA_XNACK=1 (MI300A) returns a
+!   null pointer for it, the known defect of afar-xnack1-target-is-present.f90 (nothing is
+!   recorded present in unified memory), so that cell fails for another reason
+! - legality: "If a list item that appears in a use_device_ptr clause is of type C_PTR and
+!   points to a data entity that is mapped to the device data environment, references to the list
+!   item in the structured block ... are converted into references to a device pointer that is
+!   local to the structured block and that refers to the device address of the corresponding
+!   entity" (OpenMP 5.2 §5.4.8 p.122 l.1-5); tab is mapped by target enter data and cp =
+!   c_loc(tab); the C_PTR form is the one 5.2 keeps (the non-C_PTR form is deprecated, l.8-10).
+!   omp_get_mapped_ptr is OpenMP 5.1 (§3.8.11); the pre-run check accepts the program
+! - evidence: results/harvest-known/main.wingtip (hk-040, gate: confirmed), results/harvest-known/probes.wingtip.jsonl
+program v040pp
+  use iso_c_binding
+  use omp_lib
+  implicit none
+  integer, parameter :: n = 1024
+  integer, allocatable, target :: tab(:)
+  type(c_ptr), target :: cp
+  type(c_ptr) :: p_ptr, p_map
+  integer :: hk_host
+  allocate(tab(n))
+  tab = 7
+  !$omp target enter data map(to: tab)
+  p_map = omp_get_mapped_ptr(c_loc(tab), omp_get_default_device())
+  cp = c_loc(tab)
+  !$omp target data use_device_ptr(cp)
+  p_ptr = cp
+  !$omp end target data
+  !$omp target exit data map(delete: tab)
+  print '(a,z0)', 'host   ', transfer(c_loc(tab), 0_c_intptr_t)
+  print '(a,z0)', 'mapped ', transfer(p_map, 0_c_intptr_t)
+  print '(a,z0)', 'seen   ', transfer(p_ptr, 0_c_intptr_t)
+  print '(a,z0)', 'loc(cp) ', transfer(c_loc(cp), 0_c_intptr_t)
+  hk_host = 1
+  !$omp target map(tofrom: hk_host)
+  if (.not. omp_is_initial_device()) hk_host = 0
+  !$omp end target
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', hk_host, ' check=', merge('pass', 'fail', c_associated(p_ptr, p_map))
+end program v040pp
+! site:
+! title: nvfortran aborts on use_device_ptr of a C_PTR to mapped data ("data in use_device clause was not found")
+! end site

offload/_root/data/findings/harvest/nvhpc2511-target-nowait-in-parallel-for-ice.c

@@ -0,0 +1,59 @@
+// # Finding (known-issues harvest): NVHPC 25.11 crashes compiling a target nowait
+//   region in the worksharing loop of a parallel region
+//
+// - source: the NVIDIA forum topic 251225 (NVHPC 23.3, "Internal compiler error. targetinfo
+//   symbol not found in uplevel struct"; TPR 33521, "fixed in our 25.7 release" per the vendor);
+//   data/bench/harvest-known hk-030 (trip count num_iterations, the posted form); this file has a
+//   constant trip count (data/reports/harvest-known/c030-const-trip.c), which fails the same way
+// - compilers: NVHPC nvc 25.11, -mp=gpu -gpu=cc80; NVHPC 26.9 compiles and runs it
+// - expected: the program compiles and prints bad = 0, RESULT ... check=pass: each target task
+//   writes one element of a[i:1]; the deferred target tasks complete at the implicit barrier
+//   that ends the parallel region
+// - actual: "NVC++-F-0000-Internal compiler error. targetinfo symbol not found in uplevel struct
+//   1209", both memory-mode builds
+// - control (same compiler): without nowait the program compiles and runs
+//   (data/reports/harvest-known/c030-no-nowait.c); NVHPC 26.9 compiles and runs this file
+// - other families: AFAR compiles and runs it (bad = 0) on gfx90a and gfx942; CCE 19/20/21
+//   compile it. CCE 19 and 21 at HSA_XNACK=0 lost one target task's element of the posted form
+//   (hk-030) in the loaded matrix run (bad = 1, then 2; gate: nondeterministic; 20 repeats on an
+//   idle node pass, as do its controls); not claimed
+// - legality: "The target construct generates a target task ... If the nowait clause is
+//   present, execution of the target task may be deferred" (OpenMP 5.2 §13.8 p.284 l.14-17).
+//   Ruled legal by hand (fix; the confirmer's scope rule does not vet host parallel and
+//   for, R04): a is shared in the parallel region, i is private to the worksharing loop and
+//   firstprivate in the target; each target task maps a disjoint one-element section a[i:1], so
+//   no storage is mapped twice; the deferred target tasks complete by the worksharing loop's
+//   implicit barrier, and the host code that reads a runs after the region. An internal compiler
+//   error is a defect on any input. The pre-run check accepts the program
+// - evidence: results/harvest-known/main.wingtip (hk-030, gate: confirmed), results/harvest-known/probes.wingtip.jsonl
+#include <omp.h>
+#include <stdio.h>
+
+int main(void)
+{
+    int num_iterations = 100;
+    int a[100];
+    for (int i = 0; i < 100; ++i) a[i] = -1;
+    #pragma omp parallel
+    {
+        #pragma omp for
+        for (int i = 0; i < 100; ++i) {
+            #pragma omp target nowait map(tofrom: a[i:1])
+            {
+                a[i] = 2 * i + 1;
+            }
+        }
+    }
+    int bad = 0;
+    for (int i = 0; i < num_iterations; ++i)
+        if (a[i] != 2 * i + 1) ++bad;
+    printf("bad = %d\n", bad);
+    int hk_host = 1;
+    #pragma omp target map(tofrom: hk_host)
+    hk_host = omp_is_initial_device();
+    printf("RESULT ran_on_host=%d check=%s\n", hk_host, bad == 0 ? "pass" : "fail");
+    return 0;
+}
+// site:
+// title: nvc 25.11 crashes compiling a target nowait region in the worksharing loop of a parallel region
+// end site

offload/_root/data/findings/hecbench/controls/f16-ctl-float-array.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+typedef float half_t;
+
+int main(void)
+{
+  const int size = 1024;
+  int hf = 1;
+  half_t *ax = malloc(size * sizeof(half_t));
+  float *out = malloc(size * sizeof(float));
+  float total = 0.f;
+  for (int i = 0; i < size; i++) { ax[i] = 2; out[i] = 0; }
+  #pragma omp target map(from: hf)
+  hf = omp_is_initial_device() ? 1 : 0;
+
+  #pragma omp target map(to: ax[0:size]) map(from: out[0:size])
+  for (int i = 0; i < size; i++)
+    out[i] = (float)ax[i];
+
+  for (int i = 0; i < size; i++) total += out[i];
+  printf("total= %f\n", total);
+  printf("RESULT ran_on_host=%d check=%s\n", hf, total == 2048.f ? "pass" : "fail");
+  free(ax);
+  free(out);
+  return 0;
+}

offload/_root/data/findings/hecbench/controls/pc-ctl-builtin-popcount.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+#define M1 0x5555555555555555UL
+#define M2 0x3333333333333333UL
+#define M4 0x0f0f0f0f0f0f0f0fUL
+#define H01 0x0101010101010101UL
+
+int main(void)
+{
+  const int length = 1024;
+  int hf = 1, bad = 0;
+  unsigned long *data = malloc(length * sizeof(unsigned long));
+  int *result = malloc(length * sizeof(int));
+  for (int i = 0; i < length; i++)
+    data[i] = (unsigned long)(i + 1) * 0x9E3779B97F4A7C15UL;
+  #pragma omp target map(from: hf)
+  hf = omp_is_initial_device() ? 1 : 0;
+
+  #pragma omp target map(to: data[0:length]) map(from: result[0:length])
+  for (int i = 0; i < length; i++) {
+    unsigned long x = data[i];
+    result[i] = __builtin_popcountll(x);
+  }
+
+  for (int i = 0; i < length; i++) {
+    int count = 0;
+    for (unsigned long y = data[i]; y; count++) y &= y - 1;
+    if (count != result[i]) bad++;
+  }
+  printf("bad= %d\n", bad);
+  printf("RESULT ran_on_host=%d check=%s\n", hf, bad == 0 ? "pass" : "fail");
+  free(data);
+  free(result);
+  return 0;
+}

offload/_root/data/findings/hecbench/controls/pc-ctl-shift-sum.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+#define M1 0x5555555555555555UL
+#define M2 0x3333333333333333UL
+#define M4 0x0f0f0f0f0f0f0f0fUL
+#define H01 0x0101010101010101UL
+
+int main(void)
+{
+  const int length = 1024;
+  int hf = 1, bad = 0;
+  unsigned long *data = malloc(length * sizeof(unsigned long));
+  int *result = malloc(length * sizeof(int));
+  for (int i = 0; i < length; i++)
+    data[i] = (unsigned long)(i + 1) * 0x9E3779B97F4A7C15UL;
+  #pragma omp target map(from: hf)
+  hf = omp_is_initial_device() ? 1 : 0;
+
+  #pragma omp target map(to: data[0:length]) map(from: result[0:length])
+  for (int i = 0; i < length; i++) {
+    unsigned long x = data[i];
+    x -= (x >> 1) & M1;
+    x = (x & M2) + ((x >> 2) & M2);
+    x = (x + (x >> 4)) & M4;
+    x += x >> 8;
+    x += x >> 16;
+    x += x >> 32;
+    result[i] = x & 0x7f;
+  }
+
+  for (int i = 0; i < length; i++) {
+    int count = 0;
+    for (unsigned long y = data[i]; y; count++) y &= y - 1;
+    if (count != result[i]) bad++;
+  }
+  printf("bad= %d\n", bad);
+  printf("RESULT ran_on_host=%d check=%s\n", hf, bad == 0 ? "pass" : "fail");
+  free(data);
+  free(result);
+  return 0;
+}

offload/_root/data/findings/hecbench/gcc-c-float16-array-in-target-lto-ice.c

@@ -0,0 +1,65 @@
+// # Finding (hecbench): GCC: a target region that reads an array of _Float16 values crashes the compiler (lto1)
+//
+// - toolchains and modes that fail: gcc_g90 (GCC 16.2.0), gcc_sm80 (GCC 16.2.0); modes: copy; -O2
+// - build: gcc -fopenmp -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90); gcc -fopenmp
+//   -foffload=nvptx-none -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+// - failure: ice
+// - observed: `Please submit a full bug report, with preprocessed source (by using -freport-bug).`; identical signature on 2 of 2
+//   failing cells
+// - expected: compiles and prints `total= 2048.000000` with `check=pass`
+// - rule: "The functionality added to the target directive is the inclusion of an executable region to be executed on a device"
+//   (5.2 §13.8 p.284 l.12-13): the region here is a loop that converts each element of a mapped array of _Float16 to float, and
+//   the specification names no base type that a target region may not use; with float elements instead the compile succeeds
+// - same-compiler control: controls/f16-ctl-float-array.c (one change from this file; correct on gcc_g90 (GCC 16.2.0), gcc_sm80
+//   (GCC 16.2.0); rows results/hecbench/red/tio_g90.jsonl, results/hecbench/red/tuo.jsonl, results/hecbench/red/wt1.jsonl)
+// - other families: afar (AFAR 24.3.0), cce19 (CCE 19.0.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4), nvhpc
+//   (NVHPC 25.11), nvhpc269 (NVHPC 26.9) run the file correctly (rows results/hecbench/red/tio_g90.jsonl,
+//   results/hecbench/red/tuo.jsonl, results/hecbench/red/wt1.jsonl)
+// - gate and confirmer: campaign gate of the programs below: 1 cells, 1 confirmed in the four environments (a-d; (c) on another
+//   node or GPU; rows results/hecbench/dev/gate_reruns.part.tioga36.2090963.jsonl,
+//   results/hecbench/dev/gate_reruns.part.tioga39.2185748.jsonl); 2 of 2 cells reproduce in all four environments (a-d; (c) on
+//   another node or GPU than (a); rows results/hecbench/red/tio_g90.jsonl, results/hecbench/red/tio_gate_abd.jsonl,
+//   results/hecbench/red/tio_gate_c.jsonl, results/hecbench/red/wt1.jsonl, results/hecbench/red/wt_gate_abd.jsonl,
+//   results/hecbench/red/wt_gate_c.jsonl)
+// - origin: HeCBench `src/f16sp-omp/main.cpp` (https://github.com/ORNL/HeCBench, commit
+//   8f44ff3e69fa003f870963045988190a275534cb), whose gcc_g90 and gcc_sm80 cells fail with the same compiler line, `lto1: internal
+//   compiler error: in make_ssa_name_fn, at tree-ssanames.cc:355`. This file is a small program written for this finding and
+//   reduced with tools/reduce.py; it holds no benchmark source.
+// - programs (1): hecbench-f16sp-omp
+// - legality: offload.engine.prerun.check (the rules, and AFAR's front end on Tuolumne, 2026-11-06: two witnesses) accepts this file
+//   and the control; CCE and NVHPC compile and run it correctly (front ends of two other families). GCC is a compiler under test
+//   only and never a legality witness.
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+typedef _Float16 half_t;
+
+int main(void)
+{
+  const int size = 1024;
+  int hf = 1;
+  half_t *ax = malloc(size * sizeof(half_t));
+  float *out = malloc(size * sizeof(float));
+  float total = 0.f;
+  for (int i = 0; i < size; i++) { ax[i] = 2; out[i] = 0; }
+  #pragma omp target map(from: hf)
+  hf = omp_is_initial_device() ? 1 : 0;
+
+  #pragma omp target map(to: ax[0:size]) map(from: out[0:size])
+  for (int i = 0; i < size; i++)
+    out[i] = (float)ax[i];
+
+  for (int i = 0; i < size; i++) total += out[i];
+  printf("total= %f\n", total);
+  printf("RESULT ran_on_host=%d check=%s\n", hf, total == 2048.f ? "pass" : "fail");
+  free(ax);
+  free(out);
+  return 0;
+}
+
+// site:
+// title: GCC: compiler crash on _Float16 data in a target region
+// summary: GCC 16.2 stops with an internal compiler error in lto1 when a target region reads an array of _Float16 values; the same program with float elements compiles and runs.
+// control: hecbench/controls/f16-ctl-float-array.c one change from the finding; correct on gcc_g90, gcc_sm80
+// end site

offload/_root/data/findings/hecbench/gcc-c-swar-popcount-assembler-error.c

@@ -0,0 +1,80 @@
+// # Finding (hecbench): GCC (gfx90a): a bit-counting loop in a target region makes the generated assembly invalid
+// (v_bcnt_u32_b32)
+//
+// - toolchains and modes that fail: gcc_g90 (GCC 16.2.0); modes: copy; -O2
+// - build: gcc -fopenmp -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2
+// - failure: ice
+// - observed: `<tmpdir>/ccRlCeSn.mkoffload.2.s:126:2: error: too few operands for instruction`; identical signature on 1 of 1
+//   failing cells
+// - expected: compiles and prints `bad= 0` with `check=pass`
+// - rule: "The functionality added to the target directive is the inclusion of an executable region to be executed on a device"
+//   (5.2 §13.8 p.284 l.12-13): the region is a loop of integer shifts, masks and one multiplication (the parallel-sum popcount
+//   idiom); the specification limits no integer operation in a target region, and with the last step written as shifts and adds,
+//   or as __builtin_popcountll, the compile succeeds
+// - same-compiler control: controls/pc-ctl-shift-sum.c (one change from this file; correct on gcc_g90 (GCC 16.2.0); rows
+//   results/hecbench/red/tio_g90.jsonl, results/hecbench/red/tuo.jsonl, results/hecbench/red/wt1.jsonl);
+//   controls/pc-ctl-builtin-popcount.c (one change from this file; correct on gcc_g90 (GCC 16.2.0); rows
+//   results/hecbench/red/tio_g90.jsonl, results/hecbench/red/tuo.jsonl, results/hecbench/red/wt1.jsonl)
+// - other families: afar (AFAR 24.3.0), cce19 (CCE 19.0.0), cce20 (CCE 20.0.2), cce21 (CCE 21.0.3), cce21_4 (CCE 21.0.4), nvhpc
+//   (NVHPC 25.11), nvhpc269 (NVHPC 26.9), gcc_sm80 (GCC 16.2.0) run the file correctly (rows results/hecbench/red/tio_g90.jsonl,
+//   results/hecbench/red/tuo.jsonl, results/hecbench/red/wt1.jsonl)
+// - gate and confirmer: campaign gate of the programs below: 1 cells, 1 confirmed in the four environments (a-d; (c) on another
+//   node or GPU; rows results/hecbench/dev/gate_reruns.part.tioga36.2090963.jsonl,
+//   results/hecbench/dev/gate_reruns.part.tioga39.2185748.jsonl); 1 of 1 cells reproduce in all four environments (a-d; (c) on
+//   another node or GPU than (a); rows results/hecbench/red/tio_g90.jsonl, results/hecbench/red/tio_gate_abd.jsonl,
+//   results/hecbench/red/tio_gate_c.jsonl)
+// - origin: HeCBench `src/popcount-omp/main.cpp` (https://github.com/ORNL/HeCBench, commit
+//   8f44ff3e69fa003f870963045988190a275534cb), whose gcc_g90 cell fails at the link with `error: too few operands for
+//   instruction` in mkoffload's assembly. This file is a small program written for this finding and reduced with tools/reduce.py;
+//   the bit-counting steps are the textbook parallel-sum popcount, and it holds no benchmark source.
+// - programs (1): hecbench-popcount-omp
+// - legality: offload.engine.prerun.check (the rules, and AFAR's front end on Tuolumne, 2026-11-06: two witnesses) accepts this file
+//   and the controls; AFAR, CCE and NVHPC compile and run it correctly (front ends of three other families). GCC is a compiler
+//   under test only and never a legality witness.
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+
+#define M1 0x5555555555555555UL
+#define M2 0x3333333333333333UL
+#define M4 0x0f0f0f0f0f0f0f0fUL
+#define H01 0x0101010101010101UL
+
+int main(void)
+{
+  const int length = 1024;
+  int hf = 1, bad = 0;
+  unsigned long *data = malloc(length * sizeof(unsigned long));
+  int *result = malloc(length * sizeof(int));
+  for (int i = 0; i < length; i++)
+    data[i] = (unsigned long)(i + 1) * 0x9E3779B97F4A7C15UL;
+  #pragma omp target map(from: hf)
+  hf = omp_is_initial_device() ? 1 : 0;
+
+  #pragma omp target map(to: data[0:length]) map(from: result[0:length])
+  for (int i = 0; i < length; i++) {
+    unsigned long x = data[i];
+    x -= (x >> 1) & M1;
+    x = (x & M2) + ((x >> 2) & M2);
+    x = (x + (x >> 4)) & M4;
+    result[i] = (x * H01) >> 56;
+  }
+
+  for (int i = 0; i < length; i++) {
+    int count = 0;
+    for (unsigned long y = data[i]; y; count++) y &= y - 1;
+    if (count != result[i]) bad++;
+  }
+  printf("bad= %d\n", bad);
+  printf("RESULT ran_on_host=%d check=%s\n", hf, bad == 0 ? "pass" : "fail");
+  free(data);
+  free(result);
+  return 0;
+}
+
+// site:
+// title: GCC: invalid assembly for a bit-counting loop on MI250X
+// summary: GCC 16.2 for gfx90a emits a v_bcnt_u32_b32 instruction with a missing operand for the parallel-sum popcount loop in a target region, so the offload link fails; shift-and-add and the builtin compile.
+// control: hecbench/controls/pc-ctl-shift-sum.c one change from the finding; correct on gcc_g90
+// control: hecbench/controls/pc-ctl-builtin-popcount.c one change from the finding; correct on gcc_g90
+// end site