offtarget 0.1.0__py3-none-any.whl

offload/_root/catalog/omp/derivations.yaml

@@ -0,0 +1,177 @@
+# Hand derivations of catalog programs' expected results.
+#
+# Each entry derives, from the spec text alone (section and page of the
+# program's own version), the values a conforming execution of the program
+# produces and shows that its check accepts them (value check=pass) or that
+# the run must end in runtime error termination (value error_termination).
+# offload.engine.gen writes the text into the program header as
+# `! derivation (<value>): <text>` (legal programs only; the header is not
+# part of the audited body, offload.engine.mutate.body_sha); tools/derive/expected.py
+# reads it as the `derivation` source (offload.engine.expected.
+# derivation_evidence), which counts next to the program's own oracle (the
+# brief: "an independent hand-derived expected value with the derivation
+# written in the program header"). A derivation is written by reading the
+# program as generated, not the generator's check code, and states every
+# assumption that is not a spec guarantee. Programs whose expected value
+# the spec does not fix (it depends on the memory mode or on an
+# implementation-defined resource; the relaxed
+# induction forms, whose new list item at the start of a chunk the text
+# does not fix) have no entry, and no entry may rest on a ruling of this
+# project (tests/engine/test_gen.py); data/reports/
+# triage-2026-10.md lists them.
+#
+# Keys: atom, versions, value, text (one line; {cite:<key>} is replaced by
+# the version's entry in `cites`).
+cites:
+  linear: {50: "5.0 §2.19.4.6 p.292", 52: "5.2 §5.4.6 p.118", 60: "6.0 §7.5.6 p.233"}
+  declare_simd: {50: "5.0 §2.9.3.3 p.116", 52: "5.2 §7.7 p.202", 60: "6.0 §9.8 p.341"}
+  scan: {50: "5.0 §2.9.6 p.132", 52: "5.2 §5.6 p.141", 60: "6.0 §7.7 p.266"}
+  allocate: {50: "5.0 §2.11.4 p.159", 52: "5.2 §6.6 p.179", 60: "6.0 §8.6 p.314"}
+  ancestor: {50: "5.0 §2.12.5 p.174", 52: "5.2 §13.2 p.276 and §8.2.1 p.212", 60: "6.0 §15.2 p.451 and §10.5.1.3 p.359"}
+  nohost: {52: "5.2 §13.1 p.275", 60: "6.0 §15.1 p.450"}
+  iterator: {52: "5.2 §3.2.6 p.67", 60: "6.0 §5.2.6 p.169"}
+  update: {50: "5.0 §2.12.6 p.176", 52: "5.2 §13.9 p.289", 60: "6.0 §15.9 p.465"}
+  use_device_ptr: {52: "5.2 §5.4.8 p.121", 60: "6.0 §7.5.8 p.236"}
+  is_device_ptr: {52: "5.2 §5.4.7 p.120", 60: "6.0 §7.5.7 p.235"}
+  map: {50: "5.0 §2.19.7.1 p.315", 52: "5.2 §5.8.3 p.152", 60: "6.0 §7.9.6 p.283"}
+  mapper: {50: "5.0 §2.19.7.3 p.326", 52: "5.2 §5.8.8 p.163 (Table 5.3)", 60: "6.0 §7.9.2 p.276 (Table 7.5) and §7.9.10 p.293"}
+  task_default: {50: "5.0 §2.19.1.1 p.273 and §2.19.4.1 p.283", 52: "5.2 §5.1.1 p.100 and §5.4.1 p.109", 60: "6.0 §7.1.1 p.211 and §7.5.1 p.223"}
+  has_device_addr: {52: "5.2 §5.4.9 p.123 and §5.4.10 p.123", 60: "6.0 §7.5.9 p.237 and §7.5.10 p.238"}
+  schedule: {50: "5.0 §2.9.2 pp.103-104", 52: "5.2 §11.5.3 p.252", 60: "6.0 §13.6.3 p.418 and Glossary 'chunk' p.31"}
+  dist_schedule: {50: "5.0 §2.9.4.1 pp.121-122 and §2.9.2 p.103 ('chunks')", 52: "5.2 §11.6.1 p.256", 60: "6.0 §13.7.1 p.422 and Glossary 'chunk' p.31"}
+  num_teams: {50: "5.0 §2.7 p.83", 52: "5.2 §10.2.1 p.233", 60: "6.0 §12.2.1 p.397"}
+  loop_bind: {50: "5.0 §2.9.5 pp.129-130", 52: "5.2 §11.7 p.257 and §11.7.1 p.258", 60: "6.0 §13.8 p.423 and §13.8.1 p.424"}
+  character: {50: "5.0 §1.2.6 p.12", 52: "5.2 §1.2.6 p.14 and §5.8.1 p.148", 60: "6.0 Glossary p.94 and §7.9.3 p.276"}
+entries:
+  - atom: omp.clause.linear
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "linear(x: 1) on the parallel do ({cite:linear}): on the logical iteration of i (number i - 1) the new 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 + 1 keeps x on that sequence, and the value of the sequentially last iteration, taken as the new x at the end of that iteration (3 + n after its increment, as the OpenMP Examples' linear programs assume), is assigned to the original x, which the target maps tofrom: x = 1*n + 3; the check accepts"
+  - atom: omp.clause.linear.val
+    versions: [52, 60]
+    value: check=pass
+    text: "linear(x: val, step(1)) ({cite:linear}): for a variable that is not a reference the val modifier is the default value semantics, so as without it: the new x on the iteration of i is 3 + (i - 1), b(i) = 2*i + 1 = ref(i), and the sequentially last iteration's value 3 + n is assigned to x (mapped tofrom): x = 1*n + 3; the check accepts"
+  - atom: omp.clause.linear.step
+    versions: [52, 60]
+    value: check=pass
+    text: "linear(x: step(2)) ({cite:linear}): the new x on the iteration of i is 3 + 2*(i - 1) = 2*i + 1, so x - (2*i + 1) = 0 and b(i) = 2*i + 1 = ref(i); the body adds the step, and the sequentially last iteration's value 3 + 2*n is assigned to x (mapped tofrom): x = 2*n + 3; the check accepts"
+  - atom: omp.clause.linear.step_simple_modifier
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "linear(x: 2), the step written as a simple modifier ({cite:linear}): the new x on the iteration of i is 3 + 2*(i - 1) = 2*i + 1, so b(i) = 2*i + 1 = ref(i); the sequentially last iteration's value 3 + 2*n is assigned to x (mapped tofrom): x = 2*n + 3; the check accepts"
+  - atom: omp.clause.linear.ref
+    versions: [50, 52]
+    value: check=pass
+    text: "the linear clause is on the declare simd directive of lf ({cite:declare_simd}, {cite:linear}): it describes the arguments of lf's SIMD versions; the target region calls lf from a sequential loop, where lf(x) returns 2*x(1) + 1 (2*x + 1 in the 5.0 form), so b(i) = 2*a(i) + 1 = ref(i) whichever version runs; the check accepts"
+  - atom: omp.clause.linear.uval
+    versions: [52]
+    value: check=pass
+    text: "the linear(x: uval) clause is on the declare simd directive of lf ({cite:declare_simd}, {cite:linear}): it describes lf's SIMD versions; the target region calls lf from a sequential loop and lf(x) returns 2*x + 1, so b(i) = 2*a(i) + 1 = ref(i); the check accepts"
+  - atom: omp.clause.reduction.inscan
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "reduction(inscan, +: s) with scan inclusive(s) ({cite:scan}): the statement before the scan directive is the input phase, the one after it the scan phase, which sees the sum of the updates of every iteration up to and including its own; s starts at 0, so b(i) = a(1) + ... + a(i) = i*(i + 1)/2 = ref(i); the check accepts"
+  - atom: omp.clause.allocate
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "allocate(t) with private(t) on the parallel do in a target region, allowed without an allocator because the unit has requires dynamic_allocators ({cite:allocate}): t is each thread's private copy, allocated with the default allocator; each iteration sets t = 2*a(i) before b(i) = t + 1, so b(i) = 2*i + 1 = ref(i); the check reads b only and accepts"
+  - atom: omp.clause.device.ancestor
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "the nested target device(ancestor: 1) firstprivate(t) runs on the parent device of the enclosing target region (requires reverse_offload, {cite:ancestor}) and changes only its private t; the enclosing region computes b(i) = 2*a(i) + 1 on the device and b is mapped from, so b = ref; the check reads b only and accepts"
+  - atom: omp.clause.device_type.nohost
+    versions: [52]
+    value: check=pass
+    text: "declare target to(f) device_type(nohost) makes only a non-host version of f available ({cite:nohost}); f is called only inside the target region, where f(x) = 2*x + 1, so b(i) = 2*a(i) + 1 = ref(i) (b mapped from); the check accepts"
+  - atom: omp.clause.from.iterator
+    versions: [52, 60]
+    value: check=pass
+    text: "target enter data maps a (to) and b (alloc); the host adds 10 to a and target update to(a) copies it ({cite:update}), so the device's a(i) = i + 10 and the target region writes b(i) = 2*(i + 10) + 1 on the device; target update from(iterator(k = 1:1): b(k:n)) expands to from(b(1:n)) ({cite:iterator}), so the host's b is the device's: b = ref = 2*(i + 10) + 1; the check accepts"
+  - atom: omp.clause.to.iterator
+    versions: [52, 60]
+    value: check=pass
+    text: "target enter data maps a (to) and b (alloc); the host adds 10 to a and target update to(iterator(k = 1:1): a(k:n)) expands to to(a(1:n)) ({cite:iterator}, {cite:update}), so the device's a(i) = i + 10; the target region writes b(i) = 2*(i + 10) + 1 and target update from(b) copies it back: b = ref; the check accepts"
+  - atom: omp.clause.use_device_ptr
+    versions: [52]
+    value: check=pass
+    text: "target data maps a (to) and b (from); use_device_ptr(pa, pb) makes pa and pb the device addresses of a and b inside the construct ({cite:use_device_ptr}); the nested target has is_device_ptr(pa, pb) ({cite:is_device_ptr}), so pp and qq (c_f_pointer) alias the device copies and qq(i) = 2*pp(i) + 1 writes the device's b; the end of target data copies b back: b = ref; the check accepts"
+  - atom: omp.clause.is_device_ptr
+    versions: [52]
+    value: check=pass
+    text: "target data maps a (to) and b (from); use_device_ptr(pa, pb) makes pa and pb the device addresses of a and b ({cite:use_device_ptr}); the nested target has is_device_ptr(pa, pb), so they are used as device pointers there ({cite:is_device_ptr}) and qq(i) = 2*pp(i) + 1 writes the device's b; the end of target data copies b back: b = ref; the check accepts"
+  - atom: omp.clause.map.iterator
+    versions: [52, 60]
+    value: check=pass
+    text: "map(iterator(k = 1:1), to: w(k + 1:n/2)) expands to map(to: w(2:n/2)) ({cite:iterator}, {cite:map}): until the exit data, w(2) and w(n/2) are present and w(1) and w(n/2 + 1) are not, which the copy-mode-only presence checks assert (skipped when host and device share storage); the target region writes b(i) = 2*a(i) + 1 (b mapped from): b = ref; the check accepts in both memory modes"
+  - atom: omp.clause.map.mapper
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "mapper mm maps q%v with map type to; map(mapper(mm), tofrom: s) applies it with the decayed map type: mapper to with clause tofrom gives to ({cite:mapper}); so s%v (1) is copied to the device and not back: the device writes b(i) = 2*a(i) + s%v = 2*i + 1 = ref(i), then s%v = 7 on the device only; in copy mode the host's s%v stays 1 (the copy-mode-only check), under shared storage that check is skipped; the check accepts"
+  - atom: omp.clause.map.present
+    versions: [52, 60]
+    value: error_termination
+    text: "the first target region maps a (to) and removes it at its end (reference count 0); the second target region has map(present, to: a), and on entry a is not present in the device data environment, so runtime error termination is performed ({cite:map}: 'If a map clause with a present map-type-modifier appears on a construct and on entry to the region the corresponding list item is not present in the device data environment, runtime error termination is performed'); the program never reaches continued = .true."
+  - atom: omp.clause.default.shared
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "in the parallel region c is private (c = 7 per thread); the task has default(shared), so c in the task is shared, i.e. the generating implicit task's private c ({cite:task_default}); the task sets c = 42 and taskwait waits for it, so thread 0 sets r = 42 (r mapped from); b(i) = 2*a(i) + 1 on the device; the check accepts"
+  - atom: omp.clause.has_device_addr
+    versions: [52, 60]
+    value: check=pass
+    text: "target data maps a (to) and b (from) with use_device_addr(a, b): inside it a and b refer to their device storage, whose addresses differ from the host's in copy mode (the copy-mode-only checks); the nested target has has_device_addr(a, b), so it accesses that device storage directly ({cite:has_device_addr}) and writes b(i) = 2*a(i) + 1 there; the end of target data copies b back: b = ref; the check accepts"
+  - atom: omp.clause.defaultmap.private
+    versions: [60]
+    value: check=pass
+    text: "defaultmap(private) makes c and w private in the target region (6.0 §7.9.9 p.291; a and b keep their explicit maps); the region sets c = 1 and w(i) = 2*a(i) before reading them, so b(i) = w(i) + c = 2*i + 1 on the device and b is mapped from: b = ref; the check accepts"
+  - atom: omp.clause.firstprivate.saved
+    versions: [60]
+    value: check=pass
+    text: "the saved modifier affects only replay executions of a replayable construct (6.0 §7.2 p.215: 'The saved modifier has no effect if' the construct is not replayable), and nothing here is replayable, so firstprivate(saved: c) is firstprivate(c) (6.0 §7.5.4 p.227): every thread's c starts at the original 1 and grows by 100 per iteration it runs, so mod(c, 100) = 1 and b(i) = 2*i + 1 = ref(i); the original c (mapped tofrom) is not changed: c = 1; the check accepts"
+  - atom: omp.clause.induction.strict
+    versions: [60]
+    value: check=pass
+    text: "induction(step(1), strict, +: x): with strict the new x at the beginning of each iteration is the closed form 3 + (i - 1) and the original x gets the inductor applied to the last iteration's value, 3 + n (6.0 §7.6.13 p.258, §7.6.4 p.246); so b(i) = 2*i + 1 = ref(i) and x = n + 3 (mapped tofrom); the check accepts"
+  - atom: omp.clause.local
+    versions: [60]
+    value: check=pass
+    text: "declare_target local(dv) makes dv device-local: static storage duration, visible only to tasks on that device (6.0 Glossary p.44, §7.14 p.303, §7.1.1 p.211); the first target region sets the device's dv = 5, and the second, on the same device, reads that storage: b(i) = 2*a(i) + 5 - 4 = 2*i + 1 = ref(i) (b mapped from); the check accepts"
+  - atom: omp.directive.teams_workdistribute
+    versions: [60]
+    value: check=pass
+    text: "on_dev is a declare_target variable: the first target region sets the device's copy to 1, and it keeps its value on the device; teams workdistribute divides the array assignment b = 2*a + on_dev into units of work each executed once (6.0 §13.5 p.412), so b(i) = 2*i + 1 on the device, mapped from: b = ref; the check accepts"
+  - atom: omp.directive.target_teams_workdistribute
+    versions: [60]
+    value: check=pass
+    text: "on_dev is a declare_target variable: the first target region sets the device's copy to 1, and it keeps its value on the device; target teams workdistribute divides the array assignment b = 2*a + on_dev into units of work each executed once (6.0 §13.5 p.412), so b(i) = 2*i + 1 on the device, mapped from: b = ref; the check accepts"
+  - atom: omp.clause.dist_schedule
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "num_teams(4) creates at most 4 teams (exactly 4 from 5.1, {cite:num_teams}); dist_schedule(static) without a chunk size divides the 64 iterations into contiguous non-empty chunks, at most one per initial team ({cite:dist_schedule}), so every iteration runs on one team, team(i) is a team number 0 .. nt - 1 and each team's iterations are one contiguous run, the two things dok tests (it tests no chunk size); nt >= 1 and b = ref; the check accepts"
+  - atom: omp.clause.dist_schedule.static
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "num_teams(4) creates at most 4 teams (exactly 4 from 5.1, {cite:num_teams}); dist_schedule(static) without a chunk size divides the 64 iterations into contiguous non-empty chunks, at most one per initial team ({cite:dist_schedule}), so every iteration runs on one team, team(i) is a team number 0 .. nt - 1 and each team's iterations are one contiguous run, the two things dok tests (it tests no chunk size); nt >= 1 and b = ref; the check accepts"
+  - atom: omp.clause.dist_schedule.chunk_size
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "dist_schedule(static, 4): chunks of 4 iterations assigned to the initial teams round-robin in team-number order ({cite:dist_schedule}), so iteration i runs on team mod((i - 1)/4, nt), which dok tests; nt >= 1 and b = ref; the check accepts"
+  - atom: omp.clause.schedule
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "schedule(static) without a chunk size divides the 1000 iterations into contiguous non-empty chunks, at most one per thread ({cite:schedule}), so every iteration runs on one thread of the team, tid(i) is a thread number 0 .. nthr - 1 and each thread's iterations are one contiguous run, the two things sok tests (it tests no chunk size); nthr >= 1 (omp_get_num_threads) and b = ref; the check accepts"
+  - atom: omp.clause.schedule.static
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "schedule(static) without a chunk size divides the 1000 iterations into contiguous non-empty chunks, at most one per thread ({cite:schedule}), so every iteration runs on one thread of the team, tid(i) is a thread number 0 .. nthr - 1 and each thread's iterations are one contiguous run, the two things sok tests (it tests no chunk size); nthr >= 1 (omp_get_num_threads) and b = ref; the check accepts"
+  - atom: omp.clause.schedule.chunk_size
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "schedule(static, 4): chunks of 4 iterations assigned to the threads round-robin in thread-number order ({cite:schedule}), so iteration i runs on thread mod((i - 1)/4, nthr), which sok tests; nthr >= 1 and b = ref; the check accepts"
+  - atom: omp.clause.bind.thread
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "loop bind(thread) in a parallel region: the binding thread set is the encountering thread, and each logical iteration is executed once per loop region by exactly one thread of that set ({cite:loop_bind}), so every thread runs all 64 iterations and writes hit(i, tid + 1) once each (distinct elements, so the concurrent iterations do not race): tot(t) = 64 for every thread; the team size is implementation defined and only threads 0 .. 1023 record (hit has 1024 columns), so all(tot(1:min(nthr, 1024)) == n) holds for any team size, and nthr >= 1; thread 0 writes b = ref; the check accepts"
+  - atom: omp.clause.defaultmap.character
+    versions: [50, 52, 60]
+    value: check=pass
+    text: "for Fortran a scalar variable excludes character type and a character variable is an aggregate ({cite:character}), so with no defaultmap clause ch and s are mapped tofrom and the device's ch = 'b', s = 'wxyz' come back, while the integer scalar k is firstprivate and the host's k stays 1; b = ref; the check (ch == 'b', s == 'wxyz', k == 1) accepts"

offload/_root/catalog/omp/memory_modes.yaml

@@ -0,0 +1,40 @@
+# Memory modes of the matrix.
+#
+# The headline run is HSA_XNACK=1 with transparent huge pages (what LC's
+# example job script uses; on the MI300A it makes the runtime zero-copy).
+# Copy mode (HSA_XNACK=0) runs only for the programs
+# offload.engine.run_matrix.copy_mode_programs selects:
+#
+#   - every program whose evidence is copy_mode_only (its check separates
+#     the construct from a no-op only in copy mode), and
+#   - the memory-sensitive programs below: their primary atom matches one of
+#     `atoms` (fnmatch patterns), or their id is listed in `programs`.
+#
+# `programs` holds the programs whose two modes differed in the full
+# two-mode run of 2026-10-18 (results/support_table.csv, 9 program x
+# toolchain pairs) that no atom pattern already covers. Status: provisional.
+headline_xnack: 1
+copy_xnack: 0
+memory_sensitive:
+  atoms:
+    - pattern: omp.clause.map.present
+      why: >-
+        negative probe: the run must end in the runtime's error termination
+        on absent data; AFAR terminates only in copy mode (full run:
+        AFAR wrong_answer at HSA_XNACK=1, correct_on_device at 0, 5.2 and
+        6.0)
+    - pattern: omp.clause.unified_shared_memory*
+      why: >-
+        requires unified_shared_memory, every form (bare, -required,
+        -directive_name): the program needs zero-copy memory, so copy mode
+        is where a toolchain must refuse or fail (full run: unobservable at
+        1, crash or exit 255 at 0)
+    - pattern: omp.clause.map.mapper
+      why: >-
+        CCE 19 ran the map(mapper) program on the device at HSA_XNACK=1 and
+        fell back to the host at 0 (full run, 5.2)
+  programs:
+    - id: omp52-illegal-mapitem-map-001
+      why: >-
+        CCE 19 ran it on the device at HSA_XNACK=1 and fell back to the
+        host at 0 (full run); no atom pattern covers it

offload/_root/catalog/omp/no_oracle.yaml

@@ -0,0 +1,373 @@
+# Spec basis of the programs that have no separating oracle.
+#
+# A program whose atom no single run can separate from its absence carries
+# one of three evidence categories (offload.engine.gen.NO_ORACLE), each with the
+# spec sentence that makes it so:
+#   hint_only               the spec lets an implementation ignore the form
+#                           (a hint, an assertion the program makes, or a
+#                           bound that one-at-a-time execution meets): the
+#                           report reads "accepted; conforms vacuously"
+#   implementation_defined  the spec leaves the behaviour to the
+#                           implementation: "implementation-defined"
+#   equivalent_default      the form is, by the spec, the behaviour without
+#                           it: "equivalent to the default (no separable
+#                           effect)"
+# Atoms whose behaviour the spec fixes but whose program has no check for
+# it are evidence "unverified" instead (offload.engine.gen.UNVERIFIED), never
+# one of these.
+#
+# Read by offload/engine/gen.py (no_oracle_bases). Each basis id names, per
+# version, a list of citations; the first is the sentence the header line
+# `! basis:` and the support table quote, any others add context. Every
+# `quote` is checked (tests/engine/test_gen.py) to occur verbatim (whitespace
+# aside) in the cited section of results/spec_cache/openmp-<ver>.txt, and
+# the page to lie in that section. `status: provisional` until the maintainer
+# reviews it.
+#
+# bases.<id>:
+#   status   provisional
+#   <ver>:   [{cite: "OpenMP <ver> §<sec>, p.<n>", quote: "<sentence>"}, ...]
+
+bases:
+  # --- hint_only -------------------------------------------------------------
+  simd_concurrency:          # safelen: an upper bound on concurrency
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.3.1, p.112"
+        quote: "The number of iterations that are executed concurrently at any given time is implementation defined."
+      - cite: "OpenMP 5.0 §2.9.3.1, p.112"
+        quote: "The safelen clause specifies that no two concurrent iterations within a SIMD chunk can have a distance in the logical iteration space that is greater than or equal to the value given in the clause."
+    52:
+      - cite: "OpenMP 5.2 §10.4, p.235"
+        quote: "The number of iterations that are executed concurrently at any given time is implementation defined."
+      - cite: "OpenMP 5.2 §10.4.2, p.237"
+        quote: "The safelen clause specifies that no two concurrent iterations within a SIMD chunk can have a distance in the logical iteration space that is greater than or equal to the value given in the clause."
+    60:
+      - cite: "OpenMP 6.0 §12.4, p.399"
+        quote: "The number of collapsed iterations that are executed concurrently at any given time is implementation defined."
+      - cite: "OpenMP 6.0 §12.4.2, p.401"
+        quote: "The safelen clause specifies that no two concurrent logical iterations within a SIMD chunk can have a distance in the collapsed iteration space that is greater than or equal to the length argument."
+  simdlen_hint:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.3.1, p.112"
+        quote: "The simdlen clause specifies the preferred number of iterations to be executed concurrently unless an if clause is present and evaluates to false, in which case the preferred number of iterations to be executed concurrently is one."
+    52:
+      - cite: "OpenMP 5.2 §10.4.3, p.237"
+        quote: "When the simdlen clause appears on a simd construct, length is treated as a hint that specifies the preferred number of iterations to be executed concurrently."
+    60:
+      - cite: "OpenMP 6.0 §12.4.3, p.401"
+        quote: "When the simdlen clause appears on a simd construct, length is treated as a hint that specifies the preferred number of collapsed iterations to be executed concurrently."
+  nontemporal_locality:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.3.1, p.113"
+        quote: "The nontemporal clause specifies that accesses to the storage locations to which the list items refer have low temporal locality across the iterations in which those storage locations are accessed."
+    52:
+      - cite: "OpenMP 5.2 §10.4.1, p.236"
+        quote: "The nontemporal clause specifies that accesses to the storage locations to which the list items refer have low temporal locality across the iterations in which those storage locations are accessed."
+    60:
+      - cite: "OpenMP 6.0 §12.4.1, p.400"
+        quote: "The nontemporal clause specifies that accesses to the storage locations to which the list items refer have low temporal locality across the logical iterations in which those storage locations are accessed."
+  aligned_assertion:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.3.1, p.112"
+        quote: "The aligned clause declares that the location of each list item is aligned to the number of bytes expressed in the optional parameter of the aligned clause."
+    52:
+      - cite: "OpenMP 5.2 §5.11, p.169"
+        quote: "The alignment modifier specifies the alignment that the program ensures related to the list items."
+    60:
+      - cite: "OpenMP 6.0 §7.12, p.300"
+        quote: "The alignment modifier specifies the alignment that the program ensures related to the list items."
+  close_hint:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.19.7.1, p.321"
+        quote: "The close map-type-modifier is a hint to the runtime to allocate memory close to the target device."
+    52:
+      - cite: "OpenMP 5.2 §5.8.3, p.155"
+        quote: "The close map-type-modifier is a hint to the runtime to allocate memory close to the target device."
+    60:
+      - cite: "OpenMP 6.0 §7.9.6, p.285"
+        quote: "The close-modifier is a hint that the corresponding storage should be close to the target device."
+
+  # --- implementation_defined ------------------------------------------------
+  proc_bind_bind_var:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.5.5, p.73"
+        quote: "If bind-var is not set to false then the proc_bind clause overrides the value of the first element of the bind-var ICV; otherwise, the proc_bind clause has no effect."
+      - cite: "OpenMP 5.0 §2.5.2, p.66"
+        quote: "bind-var OMP_PROC_BIND Implementation defined"
+    52:
+      - cite: "OpenMP 5.2 §2.5, p.46"
+        quote: "If bind-var is not set to false then the proc_bind clause overrides the value of the first element of the bind-var ICV; otherwise, the proc_bind clause has no effect."
+      - cite: "OpenMP 5.2 §2.2, p.40"
+        quote: "bind-var OMP_PROC_BIND Implementation defined"
+    60:
+      - cite: "OpenMP 6.0 §3.5, p.126"
+        quote: "If bind-var is not set to false then the proc_bind clause overrides the value of the first element of the bind-var ICV; otherwise, the proc_bind clause has no effect."
+      - cite: "OpenMP 6.0 §3.2, p.118"
+        quote: "bind-var OMP_PROC_BIND implementation defined"
+  order_concurrent:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.104"
+        quote: "If an order(concurrent) clause is present, then after assigning the iterations of the associated loops to their respective threads, as specified in Table 2.5, the iterations may be executed in any order, including concurrently."
+    52:
+      - cite: "OpenMP 5.2 §10.3, p.233"
+        quote: "If ordering is concurrent, the logical iterations of the associated loops may execute in any order, including concurrently."
+    60:
+      - cite: "OpenMP 6.0 §12.3, p.397"
+        quote: "If ordering is concurrent, different collapsed iterations may execute in any order, including in parallel, as if by the binding thread set of the region."
+  target_nowait:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.12.5, p.172"
+        quote: "If the nowait clause is present, execution of the target task may be deferred. If the nowait clause is not present, the target task is an included task."
+    52:
+      - cite: "OpenMP 5.2 §13.8, p.284"
+        quote: "If the nowait clause is present, execution of the target task may be deferred. If the nowait clause is not present, the target task is an included task."
+    60:
+      - cite: "OpenMP 6.0 §15.8, p.461"
+        quote: "If the nowait clause is present, execution of the target tasks may be deferred."
+  num_teams_bounds:
+    status: provisional
+    52:
+      - cite: "OpenMP 5.2 §10.2.1, p.233"
+        quote: "The number of teams created is implementation defined, but it will be greater than or equal to the lower bound and less than or equal to the upper bound."
+    60:
+      - cite: "OpenMP 6.0 §12.2.1, p.397"
+        quote: "The number of teams formed is implementation defined, but it will be greater than or equal to the lower bound and less than or equal to the upper bound."
+  schedule_auto:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.105"
+        quote: "When kind is auto, the decision regarding scheduling is delegated to the compiler and/or runtime system."
+    52:
+      - cite: "OpenMP 5.2 §11.5.3, p.253"
+        quote: "If the kind argument is auto, the decision regarding scheduling is implementation defined."
+    60:
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "If the kind argument is auto, the decision regarding scheduling is implementation defined."
+  schedule_simd_width:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.106"
+        quote: "where simd_width is an implementation-defined value."
+    52:
+      - cite: "OpenMP 5.2 §11.5.3, p.253"
+        quote: "is the chunk_size for all chunks except the first and last chunks, where simd_width is an implementation-defined value."
+    60:
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "is the chunk_size for all chunks except the first and last chunks, where simd_width is an implementation defined value."
+  schedule_nonmonotonic_order:   # monotonic: dynamic against its default
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.106"
+        quote: "When the nonmonotonic modifier is specified then chunks are assigned to threads in any order and the behavior of an application that depends on any execution order of the chunks is unspecified."
+      - cite: "OpenMP 5.0 §2.9.2, p.106"
+        quote: "When the monotonic modifier is specified then each thread executes the chunks that it is assigned in increasing logical iteration order."
+    52:
+      - cite: "OpenMP 5.2 §11.5.3, p.254"
+        quote: "When the nonmonotonic ordering-modifier is specified then chunks may be assigned to threads in any order and the behavior of an application that depends on any execution order of the chunks is unspecified."
+      - cite: "OpenMP 5.2 §11.5.3, p.254"
+        quote: "If the monotonic ordering-modifier is specified then each thread executes the chunks that it is assigned in increasing logical iteration order."
+    60:
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "When the nonmonotonic ordering-modifier is specified then chunks may be assigned to threads in any order and the behavior of an application that depends on any execution order of the chunks is unspecified."
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "If the monotonic ordering-modifier is specified then each thread executes the chunks that it is assigned in increasing collapsed iteration order."
+
+  dist_schedule_default:   # Dist_schedule(static) without a chunk size
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.4.1, p.122"
+        quote: "When no dist_schedule clause is specified, the schedule is implementation defined."
+      - cite: "OpenMP 5.0 §2.9.4.1, p.122"
+        quote: "When no chunk_size is specified, the iteration space is divided into chunks that are approximately equal in size, and at most one chunk is distributed to each initial team of the league."
+    52:
+      - cite: "OpenMP 5.2 §11.6, p.254"
+        quote: "If the dist_schedule clause is not specified, the schedule is implementation defined."
+      - cite: "OpenMP 5.2 §11.6.1, p.256"
+        quote: "if chunk_size is not specified, the iteration space is divided into chunks that are approximately equal in size, and at most one chunk is distributed to each initial team of the league."
+    60:
+      - cite: "OpenMP 6.0 §13.7, p.420"
+        quote: "If the dist_schedule clause is not specified, the loop schedule is implementation defined."
+      - cite: "OpenMP 6.0 §13.7.1, p.422"
+        quote: "approximately equal in size, and at most one chunk is distributed to each initial team of the league."
+  schedule_default:   # Schedule(static) without a chunk size
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.5.1, p.64"
+        quote: "def-sched-var - controls the implementation defined default scheduling of worksharing-loop regions."
+      - cite: "OpenMP 5.0 §2.9.2, p.105"
+        quote: "One compliant implementation of the static schedule (with no specified chunk_size) would behave as though chunk_size had been specified with value q. Another compliant implementation would assign q iterations to the first p − r threads, and q − 1 iterations to the remaining r threads."
+    52:
+      - cite: "OpenMP 5.2 §11.5, p.248"
+        quote: "If the schedule clause is not specified then the schedule is implementation defined."
+      - cite: "OpenMP 5.2 §11.5.3, p.253"
+        quote: "One compliant implementation of the static schedule (with no specified chunk_size) would behave as though chunk_size had been specified with value q. Another compliant implementation would assign q iterations to the first p − r threads, and q − 1 iterations to the remaining r threads."
+    60:
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "If the schedule clause is not specified on a worksharing-loop construct then the effect is as if the schedule clause was specified with auto as its kind argument."
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "If the kind argument is auto, the decision regarding scheduling is implementation defined."
+
+  # --- equivalent_default ----------------------------------------------------
+  schedule_default_modifier:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.103"
+        quote: "Otherwise, unless the monotonic modifier is specified, the effect is as if the nonmonotonic modifier is specified."
+      - cite: "OpenMP 5.0 §2.9.2, p.103"
+        quote: "If the static schedule kind is specified or if the ordered clause is specified, and if the nonmonotonic modifier is not specified, the effect is as if the monotonic modifier is specified."
+    52:
+      - cite: "OpenMP 5.2 §11.5.3, p.254"
+        quote: "If an ordering-modifier is not specified, the effect is as if the monotonic modifier is specified if the kind argument is static or an ordered clause is specified on the construct; otherwise, the effect is as if the nonmonotonic modifier is specified."
+    60:
+      - cite: "OpenMP 6.0 §13.6.3, p.419"
+        quote: "If an ordering-modifier is not specified, the effect is as if the monotonic ordering-modifier is specified if the kind argument is static or an ordered clause is specified on the construct; otherwise, the effect is as if the nonmonotonic ordering-modifier is specified."
+  reduction_default_modifier:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.19.5.4, p.300"
+        quote: "If reduction-modifier is not present or the default reduction-modifier is present, the behavior is as follows."
+    52:
+      - cite: "OpenMP 5.2 §5.5.8, p.134"
+        quote: "If reduction-modifier is not present or the default reduction-modifier is present, the behavior is as follows."
+    60:
+      - cite: "OpenMP 6.0 §7.6.10, p.253"
+        quote: "If reduction-modifier is not present or the default reduction-modifier is present, the behavior is as follows."
+  linear_modifier_val:
+    status: provisional
+    52:
+      - cite: "OpenMP 5.2 §5.4.6, p.118"
+        quote: "A linear-modifier may be specified as ref or uval only on a declare simd directive."
+    60:
+      - cite: "OpenMP 6.0 §7.5.6, p.233"
+        quote: "A linear-modifier may be specified as ref or uval only for linear clauses on declare_simd directives."
+  defaultmap_default:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.19.7.2, p.325"
+        quote: "If implicit-behavior is default, then the clause has no effect for the variables in the category specified by variable-category."
+    52:
+      - cite: "OpenMP 5.2 §5.8.7, p.162"
+        quote: "If implicit-behavior is default then the clause has no effect."
+    60:
+      - cite: "OpenMP 6.0 §7.9.9, p.292"
+        quote: "If implicit-behavior is default then the clause has no effect."
+  device_num_default:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.12.5, p.172"
+        quote: "If device-modifier does not appear in the clause, the behavior of the clause is as if device-modifier is device_num."
+    52:
+      - cite: "OpenMP 5.2 §13.2, p.276"
+        quote: "If device-modifier does not appear in the clause, the behavior of the clause is as if device-modifier is device_num."
+    60:
+      - cite: "OpenMP 6.0 §15.2, p.451"
+        quote: "If device-modifier does not appear in the clause, the behavior of the clause is as if device-modifier is device_num."
+  memspace_default:
+    status: provisional
+    52:
+      - cite: "OpenMP 5.2 §6.8, p.182"
+        quote: "If mem-space is not specified, the effect is as if memspace-handle is specified as omp_default_mem_space."
+    60:
+      - cite: "OpenMP 6.0 §8.8, p.316"
+        quote: "If mem-space is not specified or omp_null_mem_space is specified, the effect is as if memspace-handle is specified as omp_default_mem_space."
+  ordered_n_default:
+    status: provisional
+    50:
+      - cite: "OpenMP 5.0 §2.9.2, p.104"
+        quote: "The parameter of the ordered clause does not affect how the logical iteration space is then divided."
+      - cite: "OpenMP 5.0 §2.9.2, p.104"
+        quote: "If an ordered clause with the parameter is specified for the worksharing-loop construct, then those associated loops form a doacross loop nest."
+    52:
+      - cite: "OpenMP 5.2 §4.4.4, p.94"
+        quote: "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."
+    60:
+      - cite: "OpenMP 6.0 §6.4.6, p.206"
+        quote: "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."
+  order_unconstrained_reproducible:
+    status: provisional
+    52:
+      - cite: "OpenMP 5.2 §11.5, p.248"
+        quote: "The schedule clause is specified with static as the kind argument but not the simd ordering-modifier and the order clause is not specified with the unconstrained order-modifier."
+      - cite: "OpenMP 5.2 §10.3, p.234"
+        quote: "If order-modifier is reproducible, the loop schedule for the construct on which the clause appears is reproducible, whereas if order-modifier is unconstrained, the loop schedule is not reproducible."
+    60:
+      - cite: "OpenMP 6.0 §13.6, p.414"
+        quote: "The schedule clause is specified with static as the kind argument but not with the simd ordering-modifier and the order clause is not specified with the unconstrained order-modifier."
+      - cite: "OpenMP 6.0 §12.3, p.398"
+        quote: "If order-modifier is reproducible, the loop schedule for the construct on which the clause appears is reproducible, whereas if order-modifier is unconstrained, the loop schedule is not reproducible."
+  default_category_all:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §7.5.1, p.223"
+        quote: "If no variable-category is specified in the clause then the effect is as if all was specified for the variable-category."
+  ref_ptr_ptee_default:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §7.9.6, p.282"
+        quote: "Unless otherwise specified, if a list item is a referencing variable then the effect of the map clause is applied to its referring pointer and, if a referenced pointee exists, its referenced pointee."
+  nowait_true_default:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §17.6, p.481"
+        quote: "If do_not_synchronize is not specified, the effect is as if do_not_synchronize evaluates to true."
+  replayable_true_default:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §14.6, p.441"
+        quote: "If replayable-expression is not specified, the effect is as if replayable-expression evaluates to true."
+  # directive-name modifiers (6.0 only)
+  dnm_own_directive:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §5.4, p.174"
+        quote: "If no directive-name-modifier is specified then the effect is as if a directive-name-modifier was specified with the directive name of the directive on which the clause appears."
+  dnm_single_leaf:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §19.2, p.528"
+        quote: "Some clauses are permitted only on a single leaf construct of the compound construct, in which case the effect is as if the clause is applied to that specific construct."
+  dnm_innermost_leaf:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §19.2, p.528"
+        quote: "Unless otherwise specified, the effect of any clause with the innermost-leaf property on a compound construct is as if it is applied only to the innermost leaf construct that permits it."
+  dnm_all_privatizing:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §19.2, p.528"
+        quote: "The effect of any clause with the all-privatizing property on a compound directive is as if it is applied to all leaf constructs that permit the clause and to which a data-sharing attribute clause that may create a private copy of the same list item is applied."
+  dnm_firstprivate:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §19.2, p.528"
+        quote: "To a worksharing construct that accepts the clause if one is among the constituent constructs;"
+  dnm_reduction:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §19.2, p.529"
+        quote: "For the parallel and teams constructs above, the effect of the reduction clause instead is as if each list item or, for any list item that is an array item, its corresponding base array or corresponding base pointer appears in a shared clause for the construct."
+  dnm_thread_limit:
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §12.2, p.394"
+        quote: "If a thread_limit clause is not present on the teams construct, but the construct is closely nested inside a target construct on which the thread_limit clause is specified, the behavior is as if that thread_limit clause is also specified for the teams construct."
+
+  # --- C programs whose port showed the oracle does not separate ---
+  default_parallel_shared:   # default(shared: <category>) on parallel
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §7.1.1, p.213"
+        quote: "In a parallel construct, if no default clause is present, these variables are shared."
+  reduction_original_default:  # original(shared) of a shared item
+    status: provisional
+    60:
+      - cite: "OpenMP 6.0 §7.6.10, p.252"
+        quote: "If the sharing argument is specified as default, original list items are assumed to be shared in the enclosing context unless determined not to be shared according to the rules specified in Section 7.1."