offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/oop--gcc-acc-parent-and-member-data-rejected.json

@@ -0,0 +1,141 @@
+{
+ "finding": "oop/gcc-acc-parent-and-member-data-rejected.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-06",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Per OpenACC 3.4 a derived-type variable in a data clause copies its members, but data behind allocatable members is not copied. copy(x%a) separately allocates and copies the allocatable component, so listing both is the intended way to transfer such data. No rule forbids a member and its parent in the same construct. The gfortran message is an implementation restriction. Some uncertainty about attachment semantics."
+  },
+  {
+   "run": "run-20261113/batch-78",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "OpenACC 3.4 data-clause restrictions do not forbid naming a derived-type variable in copyin and one of its allocatable members in copy on the same directive. Copying x does not copy data reached through an allocatable member, so x%a is separate data. The gfortran message is its own diagnostic. The spec text on overlapping or aliased data is thin, so required acceptance is not certain."
+  },
+  {
+   "run": "run-v2-20261113/batch-18",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "copyin(x) copies the derived type but not the data behind the allocatable member; copy(x%a) then copies that member and attaches it. A member of a derived type may appear in a data clause, and the restrictions only prohibit array notation on a parent. The parallel loop is independent, giving r1=4160. Rejecting the mix of x and x%a is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-13",
+     "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-85",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Fortran derived type x with an allocatable member. copyin(x) copies the members but not the data behind the allocatable member; copy(x%a) is a separate member var that allocates and attaches that data. OpenACC 3.4 allows composite members in data clauses and has no rule against a variable and its member in the same construct. The gfortran-style error about mixed component and non-component access is not a spec rule, so refusing the program is not permitted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-32",
+     "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": "c7d1be751b7b2685167bc8a8214c9198ee9d28557b76453845cc41144a23fb4d",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113/batch-04",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Reading A's conclusion holds. Copying x does not copy data reached through the allocatable member, so x%a is separate data. The restrictions in 3.4 forbid subarray notation on a member together with subarray notation on a parent; here no subarray notation is used. No rule forbids a member and its parent in data clauses of one construct. The compiler's mixed-access error is its own limitation. Reading B's doubt is unsupported by any restricting text."
+  },
+  {
+   "run": "adj-20261113/batch-09",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "A member of a composite variable is a valid var, and no OpenACC 3.4 restriction forbids a derived-type variable and one of its members in data clauses of the same directive. The array-notation restriction on parents of members is for update and does not apply (no subarray notation here). Copying x does not copy data behind allocatable member a, so copy(x%a) transfers it. The gfortran message is an implementation limit. Reading A is right; Reading B's doubt rests on thin text, not on a rule against it."
+  }
+ ]
+}

offload/_root/data/findings/reviews/oop--gcc-pdt-length-parameter-abort.json

@@ -0,0 +1,141 @@
+{
+ "finding": "oop/gcc-pdt-length-parameter-abort.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-18",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "A Fortran parameterized derived type with a length parameter is a mappable derived type: the specification imposes no restriction beyond type-bound procedures. Mapping tofrom and reading type parameter x%m on the device are not excluded. However, the specification does not define how length type parameters are mapped, so whether a conforming compiler must support it is unclear; no compiler recorded as passing."
+  },
+  {
+   "run": "run-20261113/batch-57",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "Parameterized derived type with a len parameter, non-allocatable scalar variable, mapped tofrom. Type parameter inquiry x%m in the target region is treated as a reference to x, already mapped. No mapping or nesting restriction found; the sum 1496 is determined."
+  },
+  {
+   "run": "run-v2-20261113/batch-110",
+   "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": "The parameterized derived type with a length parameter is mapped tofrom as a whole; x%m is a type parameter inquiry treated as a reference to x, which is mapped. The specification places no restriction on mapping such a type. Squares of 1..16 sum to 1496 and r1 is 16, so the expected output is determined. The device crash is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-46",
+     "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-31",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The derived type with a length parameter is a Fortran type with no listed OpenMP restriction; mappable-type rules for Fortran exclude only type-bound procedures used in target regions, and none are used. x is explicitly mapped tofrom, x%m is a type parameter inquiry treated as a reference to its designator. The program has no race. sum of squares 1..16 is 1496, r1 is 16, so the expected output is required; the device crash is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-65",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "1dda6d5de54ba1464960195f2345bfa041f847d4ef8674ffa9f85d524b5ecece",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113/batch-03",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "A Fortran derived type with a length parameter is a mappable type: the spec places no restriction on Fortran types except type-bound procedures. x is a non-allocatable scalar of fixed size, so tofrom maps its storage; the type parameter inquiry x%m is treated as a reference to x. Reading A's doubt that length parameters are undefined for mapping has no basis in the text; Reading B is right. Result r1=16, r2=1496 is determined; the device fault is a compiler defect."
+  },
+  {
+   "run": "adj-20261113/batch-09",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "A parameterized derived type with a len parameter is not excluded from being mappable: the mappable-type definition only restricts component types and, in Fortran, type-bound procedures accessed in target regions, and none are used. x has a fixed array component a(16), so it is plain contiguous storage mapped tofrom. The inquiry x%m is treated as a reference to x, already mapped. The result r1=16, r2=1496 is determined. Reading B is right; Reading A's doubt has no basis in the text."
+  }
+ ]
+}

offload/_root/data/findings/reviews/oop--gcc-polymorphic-dispatch-abort.json

@@ -0,0 +1,217 @@
+{
+ "finding": "oop/gcc-polymorphic-dispatch-abort.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-18",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Abstract type with deferred binding, extended types mapped by tofrom, bindings sq_area/rect_area/area_of each have declare target, called in target region through class(shape) dispatch. The specification requires type-bound procedures accessed in a target region to appear in declare target, which is met for the implementations; the deferred binding and abstract interface carry no directive. The specification says nothing on how type descriptors/dispatch tables reach the device, so it is unclear that dynamic dispatch must work. Map of non-polymorphic variables is fine."
+  },
+  {
+   "run": "run-20261113/batch-53",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 2,
+    "not_found": 0
+   },
+   "reasoning": "Both type-bound implementations and the dispatching wrapper carry declare target, satisfying the Fortran derived-type restriction. The mapped variables are non-polymorphic, non-allocatable. The specification does not say how dynamic dispatch through a type descriptor works on a device, so whether the device must dispatch correctly is not stated."
+  },
+  {
+   "run": "run-v2-20261113/batch-44",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The program calls a deferred type-bound procedure through class(shape) in a target region. The specification requires all type-bound procedures accessed in a target region to appear in a declare target directive. The concrete bindings sq_area and rect_area do, but the deferred binding area has only an abstract interface that cannot carry one. The spec says nothing on how the dynamic-dispatch type information is made available on the device, so a device fault is not clearly a violation of a requirement.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-41",
+     "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
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-63",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Type-bound procedures used in a target region must appear in a declare target directive. The specific procedures do, but the deferred binding and the dynamic dispatch through a class(shape) dummy are not specified for devices. The spec does not say how a vtable or type descriptor is made usable on the device. The host descriptor pointer in an unmapped class object may be invalid on the device, so a fault is not shown to be a violation.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-49",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "d5fa2febece98e64573b4673ceea80ab6799b85e490b137e3033b41d250c51a4",
+ "instructions": "v2",
+ "verdict": "contested",
+ "why": "An independent adjudicating reading finds the result not required: The spec requires only that type-bound procedures accessed in a target region appear in a declare target directive. The specific bindings sq_area, rect_area and area_of carry declare target, so that rule is met. Neither reading finds a rule on making the dynamic type information (descriptor or vtable) of a CLASS dummy usable on the device. q and rr are mapped as non-polymorphic objects whose passed class descriptors point to host data.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113/batch-02",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The only derived-type restriction is that type-bound procedures accessed in a target region appear in declare target; sq_area, rect_area and area_of all do, and the deferred binding has no body. The mapped variables are non-polymorphic, non-allocatable, so map restrictions are met. The specification says nothing on how type descriptors or dispatch tables reach the device, so whether dynamic dispatch must work is unspecified; Reading A's result stands and Reading B's legality doubt lacks a cited rule."
+  },
+  {
+   "run": "adj-20261113/batch-11",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 2,
+    "not_found": 0
+   },
+   "reasoning": "The declare-target restriction for derived types is met for the concrete bindings and area_of, but the deferred binding area has no body to mark. Neither reading finds any text requiring dynamic dispatch through a polymorphic dummy to work on a device; the specification is silent for Fortran (the C++ text calls virtual invocation on another device unspecified). A requirement to dispatch correctly is therefore not established, so the device fault is not shown to violate the specification."
+  },
+  {
+   "run": "adj-v2-20261113b/batch-04",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The spec requires only that type-bound procedures accessed in a target region appear in a declare target directive. The specific bindings sq_area, rect_area and area_of carry declare target, so that rule is met. Neither reading finds a rule on making the dynamic type information (descriptor or vtable) of a CLASS dummy usable on the device. q and rr are mapped as non-polymorphic objects whose passed class descriptors point to host data. The spec does not define that case, so a device fault is not shown to violate a requirement.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-32",
+     "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
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113b/batch-11",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "no",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Both readings are right. Only the declare target requirement for type-bound procedures exists in the text. Nothing specifies how a polymorphic descriptor or binding table of a mapped non-polymorphic variable is made valid on the device, so a device memory fault is not shown to violate a requirement.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-32",
+     "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
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/oop--gcc-vtab-not-marked-for-offload.json

@@ -0,0 +1,113 @@
+{
+ "finding": "oop/gcc-vtab-not-marked-for-offload.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-06",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "bump is a declare target procedure with a class dummy and select type. The actual arguments e1, e2, b0 are non-polymorphic, mapped tofrom, so the polymorphic-mapping restrictions do not apply. Each type guard selects the expected branch, giving r1=10, r2=100, r3=-1. The link-time failure about the vtab not being marked for offload is an implementation limitation."
+  },
+  {
+   "run": "run-20261113/batch-74",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "e1, e2, b0 are non-polymorphic variables, so the polymorphic-allocatable map restriction does not apply. bump is declare target and uses select type on a class(base_t) dummy. Nothing in the specification makes this non-conforming, and the implied type descriptors are compiler-generated, so the expected values 10, 100, -1 are required. The link error about the vtab is a compiler defect. Slight uncertainty because the spec is silent on implicit device availability of type descriptors."
+  },
+  {
+   "run": "run-v2-20261113/batch-59",
+   "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": "Fortran derived types have no restriction beyond type-bound procedures needing declare target; none are used. bump has declare target, is called in the target region, and select type is ordinary Fortran. The mapped variables e1, e2, b0 are non-polymorphic. Nothing in the specification makes the vtab references illegal, so refusing at link time is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-38",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-87",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Mapped variables e1,e2,b0 are non-polymorphic, fixed-type, non-allocatable. bump is declare target with class(base_t) dummy and select type. No OpenMP rule forbids this; the only polymorphic restrictions found concern ALLOCATABLE polymorphic list items (copyin, 5.7.1), not applicable. A conforming compiler must compile and link it; the missing vtab marking is an implementation defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-24",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 3,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "2f9a62f0d763e74a8ab8c424f321cef23b10c1bdcc6166a09188f3711389a7f2",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}