offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/stress--nvhpc-declare-target-scalar-write-lost.json

@@ -0,0 +1,113 @@
+{
+ "finding": "stress/nvhpc-declare-target-scalar-write-lost.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-08",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "declare target(g) with an extended-list is equivalent to enter(g), so g has a corresponding list item in the device data environment for the whole program. target update to(g) assigns 101 to it, the target region computes 203, and target update from(g) assigns it back. Result 101 means the from update (or the device store) was lost. No race, no restriction broken."
+  },
+  {
+   "run": "run-20261112/batch-24",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "g is a module variable with declare target (extended-list form, equivalent to enter). target update to(g) sends 101 to the device copy, the target region computes 2*101+1=203 there, update from returns it. dev is mapped tofrom. Expected g=203; observed 101 means the device write or update is lost, a compiler bug."
+  },
+  {
+   "run": "run-v2-20261113/batch-46",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "g is a module variable with declare target, so a device copy exists. target update to(g) sends 101, the target region computes 203 on the device (g is not firstprivate since it is declare target), and target update from(g) makes the host copy consistent, giving 203. Observed 101 means the update from did not take effect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-36",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-84",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "g is a module variable named in declare target, treated as an enter clause, so it has a device copy. target update to(g) copies 101 to the device, the target region doubles it plus one (203) on the device, and target update from(g) copies it back. Assignments of motion clauses occur when the target task executes. Host g must be 203; 101 is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-21",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "cf852d992939526ea380eab3a05ef93c2042dfe2e3dcb074dd84483809df328a",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/stress--nvhpc-lastprivate-combined-target-not-mapped.json

@@ -0,0 +1,113 @@
+{
+ "finding": "stress/nvhpc-lastprivate-combined-target-not-mapped.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-03",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "lastprivate(l) on the combined target parallel do applies to the loop. Because target is a constituent and l is not the base of a map list item, the clause also acts as map(tofrom: l) (5.2 17.2; 5.0 2.19.7 implicit rule). The lastprivate value from iteration 64 (2560) is therefore written to the mapped l and copied back to the host. Observed l=0 is wrong. No race: the lastprivate assignment is defined."
+  },
+  {
+   "run": "run-20261112/batch-28",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "For a combined construct including target, a lastprivate list item behaves as if mapped tofrom on target, so the final value (2560) is copied back to the host l. Observed l=0 is wrong."
+  },
+  {
+   "run": "run-v2-20261113/batch-39",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "For a combined target construct, a lastprivate list item that is not the base of a mapped item behaves as if it appeared in a map clause with map-type tofrom. So the last value, 64*40 = 2560, is copied back to the host l. The observed l=0 violates this.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-53",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-74",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "On a combined construct including target, a lastprivate list item that is not mapped is treated as if in a map clause with tofrom. So the last iteration value l=64*40=2560 is copied back to the host. The observed l=0 is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-22",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "d70ece5021d7f5a21e216a30384935dfa3c599a0fc515b06b7d201dba467495d",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/stress--nvhpc-target-scalar-implicit-firstprivate.json

@@ -0,0 +1,130 @@
+{
+ "finding": "stress/nvhpc-target-scalar-implicit-firstprivate.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-03",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "s is a Fortran scalar with the TARGET attribute, not in any map or data-sharing clause. The implicit data-mapping rules (5.0, 5.2, 6.0) treat it as map(tofrom), so the device update s=2*s+1 (203) is copied back. An implicit firstprivate (s stays 101) would only apply to scalars without TARGET, ALLOCATABLE or POINTER. rd gets 101 either way. Observed s=101 is a compiler bug."
+  },
+  {
+   "run": "run-20261112/batch-23",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "s is a scalar with the TARGET attribute and is not in a map clause, so the implicit rule treats it as map(tofrom). The device assignments to s are copied back and s ends at 2*101+1 = 203; rd=101 is read before the update. There is no race. This holds in 5.0, 5.2 and 6.0 text. s=101 means the implicit map was lost (firstprivate treatment)."
+  },
+  {
+   "run": "run-v2-20261113/batch-01",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "s is a scalar with the TARGET attribute, referenced in the target region and not in a map clause. The implicit data-mapping rules treat it as if mapped tofrom, in 5.0, 5.2 and 6.0 alike. The region updates s to 2*101+1=203 and it is copied back, so the expected output is required. The observed s=101 is the firstprivate result and is wrong.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-28",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-02",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-88",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "s is a scalar with the TARGET attribute and is referenced in the target region without an explicit map. Section 5.8.1 treats it as map(tofrom), not firstprivate. The device update s=2*s+1 is copied back, so s=203 is required. The observed 101 is wrong.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-27",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "7618b2f0d7acd60131c8ee7e973aa7314bc1e13dc6d76ebc57609fe1726abd64",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/target-update-sections-in-parallel.json

@@ -0,0 +1,113 @@
+{
+ "finding": "target-update-sections-in-parallel.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-12",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "b is mapped by target enter data, then set on the device. Four threads each execute target update from on a disjoint section b(lo:hi) of the present allocatable; host writes by different threads touch disjoint elements, so there is no race. lo and hi are private. After the exit data release the host holds the values updated by the four updates. The update from copies the device values to the host, so bad=0 is required."
+  },
+  {
+   "run": "run-20261112/batch-18",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "b is mapped by enter data; the target region writes it on the device. The four threads update disjoint sections b(lo:hi) of the mapped array, so there is no race, and the host then holds all values. bad must be 0."
+  },
+  {
+   "run": "run-v2-20261113/batch-41",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "b is mapped by enter data, the target region fills it on the device, and four threads each issue target update from on disjoint sections b(lo:hi) with private lo and hi. The sections do not overlap, so no data race arises on the assigned list items. Each update must copy its section to the host, so after the loop the host b holds 2*i+1 and bad is 0. A result of bad=64 means the updates did not copy.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-21",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-71",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "b is mapped by target enter data, the target region sets b(i)=2*i+1 on the device, and four threads each issue target update from on disjoint sections b(lo:hi). Host sections do not overlap, so there is no race. lo, hi and c are private. After the updates the host b holds all device values, so bad=0 is required. Observed bad=64 means the updates were lost.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-03",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "9916af5076dd6d5190e657ea3fefeb8574b80403c5652811d087f1062b22b096",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/stress/afar-c-lastprivate-combined-target-not-mapped.c

@@ -0,0 +1,72 @@
+/* # Finding: AFAR amdclang drops lastprivate's implicit map on a combined
+   # target construct (C)
+
+   - compiler: AFAR amdclang 24.0.0git (drop 24.3.0), -fopenmp --offload-arch=gfx942 (MI300A, HSA_XNACK
+     1 and 0) and gfx90a (MI250X, Tioga, XNACK 0), -O2
+   - expected: l= 2560 dev= 1. lastprivate gives l the value of the sequentially last iteration
+     (i = 64: 64 * 40) (5.2 §5.4.5), and "If the target construct is among the constituent constructs
+     and the list item is not the base variable ... of a list item that appears in a map clause, the
+     effect of the lastprivate clause is as if the same list item appears in a map clause with a
+     map-type of tofrom" (5.2 §17.2 p.340 l.27-30; 5.0 §2.14 p.219 l.18-20)
+   - actual: l= 0 dev= 1 (the region ran on the device; the final value was not copied back), on
+     MI300A at XNACK 1 and 0 and on MI250X. The same with target teams distribute lastprivate(l)
+     (lp-c-tdist.c).
+   - XNACK 1 hang check: the audit saw this program and the other unmapped forms time out
+     (rc 124 at a 60 s run limit) at XNACK 1 on tuolumne1011. It was rerun with a 600 s limit
+     (tools/jobs/run_stress_fix2.sh b; results/stress/audit/runs-fix2-hang.jsonl) on tuolumne1013, 1031
+     and 1011 (this program and lp-c-tdist.c), and the part-a run on 1014 had a 120 s limit. Fix
+     Reran the other two forms that had timed out, target teams distribute simd and target
+     parallel for (rereview-1-src/lp-tdsimd.c, lp-tpfor.c), with a 600 s limit on tuolumne1011 and 1015
+     (run_stress_fix2.sh d; runs-fix3-hang.jsonl). Every run ended in seconds with l= 0 at XNACK 1
+     and 0. The timeout did not reproduce, so the observed outcome is l= 0; the audit's
+     timeouts are recorded as unexplained.
+   - same-compiler control: the same program with map(tofrom: l)
+     (data/reports/fuzz-stress-audit/r2-lastprivate-combined-control.c): 2560 on MI300A (XNACK 1 and 0,
+     every node above) and MI250X. Also 2560: target teams distribute lastprivate(l) map(tofrom: l)
+     and target parallel for lastprivate(l) map(tofrom: l).
+     : the control passes because l is long long. With an int item the
+     explicit-map form fails too (0 or a garbage value), a second AFAR defect of items smaller than
+     8 bytes (afar-c-lastprivate-distribute-parallel-for-small-type.c); this finding's own form
+     loses the value with int and long long alike (lp= -1 from -1, both GPUs,
+     data/evidence/lead_probe/leads/lp_int_nomap.c, lp_ll_nomap.c), so it stands as stated for its long long
+     program and control.
+   - no other family can witness:
+       CCE craycc 19/20/21 give l= 0 on this program and also on the explicit-map control
+       (stress/cce-c-distribute-lastprivate-lost.c, cce-c-parallel-for-in-target.c).
+       NVHPC: NVIDIA's guide documents lastprivate on distribute as unsupported (HPC Compilers
+       User's Guide 25.11, §7.4, 2.9.4 "The lastprivate clause is not supported"; 2.14 "Clauses on
+       combined constructs are supported to the extent that the clauses are supported on the
+       component constructs"), so nvc is not expected to implement this program; it gives l= 0
+       with and without the map (stress/nvhpc-c-lastprivate-teams-distribute-parallel-for-lost.c).
+       Its target teams distribute lastprivate(l) gives 0 without a map and 2560 with one, but that
+       clause is documented as unsupported, so it is no evidence about the C rule.
+       Fix (the optional check): on target parallel for, where lastprivate is documented
+       (2.9.2), nvc 25.11 and 26.9 give l= 0 without a map (rereview-1-src/lp-tpfor.c,
+       runs-nvhpc-fix3.jsonl, both memory modes) and 2560 with one: nvc misses the implicit map
+       there too, so it is not a witness.
+     So no C front end gives the expected value for an unmapped lastprivate on a combined target
+     construct. The expected value rests on the spec text, AFAR's own explicit-map control, and the
+     same rule in Fortran, which AFAR flang and CCE ftn implement (r2f-lastprivate-combined.f90:
+     2560).
+   - legality: legal by reading: the for loop variable is private; only the lastprivate item l is
+     written in the loop; dev is written by the initial thread of the second target region
+   - evidence: results/stress/audit/runs.jsonl, runs-tioga.jsonl, runs-fix2.jsonl,
+     runs-fix2-hang.jsonl; audit rerun: data/reports/fuzz-stress-audit/rereview-1-lp.jsonl. The
+     confirmer gave needs_human (R22: the CCE cells are wrong too, so it has no witness) */
+#include <stdio.h>
+#include <omp.h>
+int main(void) {
+  long long l = 0;
+  int dev = -1;
+  #pragma omp target teams distribute parallel for lastprivate(l)
+  for (int i = 1; i <= 64; i++)
+    l = (long long) i * 40;
+  #pragma omp target map(tofrom: dev)
+  dev = omp_is_initial_device() ? 0 : 1;
+  printf("l= %lld dev= %d\n", l, dev);
+  return 0;
+}
+// site:
+// title: amdclang: lastprivate on target teams distribute parallel for does not imply map(tofrom), value lost
+// control: ../vendor/checks/src/afar/control/afar-c-lastprivate-combined-target-not-mapped-control.c map(tofrom: l) added
+// end site

offload/_root/data/findings/stress/afar-target-scalar-implicit-firstprivate.f90

@@ -0,0 +1,47 @@
+! # Draft finding: data/reports/fuzz-stress-audit/r1-target-scalar.f90 on afar
+!
+! - compiler: afar
+! - toolchain: afar; arch: gfx942; machine: tuolumne; memory mode: copy; opt: -O2
+! - program: file data/reports/fuzz-stress-audit/r1-target-scalar.f90 (f90, version 52, sha256 b1d59bfc76fdc1b7)
+! - expected: rd= 101 s= 203 dev= 1 (trusted; metamorphic + model)
+! - actual: wrong_answer rd= 101 s= 101 dev= 1 (expected rd= 101 s= 203 dev= 1)
+! - 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 rd= 101 s= 203 dev= 1 (metamorphic + model): metamorphic + model agree; witnesses: cce19/gfx942/copy,
+!   cce20/gfx942/copy, cce21/gfx942/copy
+! - 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: read against the spec (audit and re-review); checked by scope, offload.engine.rules (no checker of the
+!   family under test)
+! - witnesses: cce19/gfx942/copy, cce20/gfx942/copy, cce21/gfx942/copy
+! - withdrawn: none
+!
+! Audit, candidate 1: a scalar with the TARGET attribute referenced
+! in a target region is implicitly map(tofrom) (OpenMP 5.0 §2.19.7 p.315,
+! 5.2 §5.8.1 p.149, 6.0 §7.9.3 p.277: "If a scalar variable has the TARGET,
+! ALLOCATABLE or POINTER attribute then it is treated as if it had appeared
+! in a map clause with a map-type of tofrom"). Expected: rd= 101 s= 203 dev= 1
+program target_scalar_tofrom
+  use omp_lib
+  implicit none
+  integer(8), target :: s
+  integer(8) :: rd
+  integer :: dev
+  s = 101
+  rd = -1
+  dev = -1
+  !$omp target map(tofrom: rd, dev)
+    rd = s
+    s = 2 * s + 1
+    dev = merge(0, 1, omp_is_initial_device())
+  !$omp end target
+  print '(a,i0,a,i0,a,i0)', 'rd= ', rd, ' s= ', s, ' dev= ', dev
+end program target_scalar_tofrom
+! site:
+! title: amdflang: scalar with the TARGET attribute is treated as firstprivate in a target region (device write lost)
+! control: ../vendor/checks/src/afar/control/afar-target-scalar-implicit-firstprivate-control.f90 s mapped explicitly:
+! + map(tofrom: rd,
+! + dev, s)
+! end site

offload/_root/data/findings/stress/cce-acc-declare-create-scalar-serial-firstprivate.f90

@@ -0,0 +1,43 @@
+! # Finding: CCE OpenACC treats a "declare create" module scalar as
+! # firstprivate in a serial construct
+!
+! - compilers: CCE ftn 19.0.0, 20.0.2, 21.0.3 (-h acc), MI300A (gfx942) HSA_XNACK 1 and 0, and
+!   MI250X (gfx90a, Tioga, HSA_XNACK 0); -O2
+! - expected: g= 203. g is in a data clause on a declare directive, so its data attributes are
+!   explicitly determined (OpenACC 3.4 §2.6 p.40 l.1331-1334); a variable in a data clause on a
+!   visible declare directive gets no implicit data attribute (§2.6.2 p.41 l.1372-1373, 1387); the
+!   data lifetime of a declare in a module's declaration section is the whole program (§2.13 p.81
+!   l.2983-2986), and the global variable is statically allocated in device memory with structured
+!   reference count one (§2.13.2 p.83 l.3051-3052). So the serial region writes the device copy
+!   (set to 101 by "update device"), and "update self" returns 203
+! - caveat: 3.4 does not define "visible" for a declare directive reached by USE association. Read
+!   together, the sections above leave no textual support for a firstprivate reading, but the
+!   finding rests on that reading of "visible"
+! - actual: g= 101 (CCE 19/20/21, MI300A both XNACK settings; MI250X)
+! - control (same compiler): serial present(g)
+!   (data/reports/fuzz-stress-audit/r3-acc-declare-create-scalar-control.f90): 203 on CCE 19/20/21;
+!   the earlier review's kernels form is 203 too
+! - other families: NVHPC 25.11 and 26.9 (nvfortran -acc=gpu, A100, separate and managed) give 203
+! - legality: legal by reading: serial, a module scalar, update device/self of a declared variable
+! - evidence: results/stress/audit/runs.jsonl, runs-tioga.jsonl, runs-nvhpc.jsonl. The confirmer
+!   gave needs_human (R22); the audit counts the A100 results as the other-family witness
+module acc_scalar_m
+  implicit none
+  integer(8) :: g
+  !$acc declare create(g)
+end module acc_scalar_m
+program acc_declare_scalar
+  use acc_scalar_m
+  implicit none
+  g = 101
+  !$acc update device(g)
+  !$acc serial
+    g = 2 * g + 1
+  !$acc end serial
+  !$acc update self(g)
+  print '(a,i0)', 'g= ', g
+end program acc_declare_scalar
+! site:
+! title: ftn -h acc: a module scalar in declare create is treated as firstprivate in a serial region (write lost)
+! control: ../vendor/checks/src/cce/control/cce-acc-declare-create-scalar-serial-firstprivate-control.f90 serial present(g)
+! end site