builder: emitAnyCall full PURE conversion (W27c) + Phase A.5 wrap

SonicField · SonicField · commit 0810be43f892 · 2026-04-25T14:34:25.000-07:00
Per supervisor 21:23:07Z + theologian 21:23:08Z + theologian P7 audit 20:53:51Z. Moves emitAnyCall from PARTIAL Cat-B to PURE-CONVERTED (Phase 3D 98/100 → 99/100). One PARTIAL Cat-B remains: emitLoadMethodStatic (blocked on VTableByteOffset wrapper, landed in push 58). CHANGES: C body (Python/jit/hir/builder_emit_c.c hir_builder_emit_any_call_c): - New signature: drop call_kind/is_kw_arg/is_awaited/const_arg params; add opcode (raw int) and BcByteOffset base_offset (P5 wrapper). - Move opcode→PhxCallKind switch into C body. CALL/CALL_FUNCTION_EX from Include/opcode.h; CALL_FUNCTION/_KW/CALL_KW/CALL_METHOD from Python/jit_common/opcode_stubs.h (stubbed >255 in 3.12 but kept for forward compat). - INVOKE_FUNCTION/NATIVE/METHOD opcode constants local-#define'd in C body (209/216/185 from Python/jit_interp/3.12/cinder_opcode_ids.h). Local-define avoids pulling cinder_opcode.h which would shadow Include/opcode.h's BINARY_OP_ADD_INT and break BINARY_OP specialization #ifdef (per existing comment at builder_emit_c.c:30). Guarded with #ifndef so future direct cinder_opcode_ids.h include doesn't conflict. - is_awaited hardcoded 0 for 3.12 with #if PY_VERSION_HEX guard + #error fallback for older Python (Phoenix targets 3.12 exclusively). Older-Python path would need C-side bc_it/bc_instr accessors (out- of-scope; covered by existing C++ stub history in git log). - const_arg = PyTuple_GET_ITEM(code->co_consts, oparg) for INVOKE_*. Per HIRBuilder::constArg @ builder.cpp pre-conversion: borrowed ref, no GC trigger, no refcount. Lifetime = code object = compile duration. Theologian 20:53:51Z P7 audit confirmed safe to extract on C side. - base_offset.v unwrap at the one boundary (hir_builder_emit_call_method_exception_handler_inline_c, raw-int API). C++ stub (Python/jit/hir/builder.cpp HIRBuilder::emitAnyCall): - Shrinks from 67 lines to 12 lines: pure type marshaling delegation. - Wraps base_offset via bc_byte_offset_from_int factory (Phase A.5). - Added bytecode_c.h include for BcByteOffset visibility. P6 EXECUTION-PATH COVERAGE: - PHX_CALL_KIND_CALL_METHOD (CALL/CALL_METHOD/CALL_KW): EXERCISED by test_exc_raise_catch (CALL ValueError(...)) + 4 W-2A-DISPATCH-COVERAGE sentinels (try/else, try/finally with raise, nested try, raise-in-handler) + 4 W-2B-RECONVERT sentinels (raise/catch, BINARY_SUBSCR_DICT-in-try, continue-in-loop, multi-except-in-loop) + test_multiple_exceptions_in_loop. - PHX_CALL_KIND_CALL_EX (CALL_FUNCTION_EX): EXERCISED indirectly by any test using *args/**kwargs unpacking; covered by Phoenix CPython suite. - PHX_CALL_KIND_VECTOR_CALL (CALL_FUNCTION/_KW): DEAD in 3.12 (stubbed >255). Switch case kept for forward compat with older Python builds. - PHX_CALL_KIND_INVOKE_FUNCTION/NATIVE/METHOD: COVERAGE GAP. INVOKE_* opcodes are Cinder static-Python only; vanilla CPython 3.12 compiler does NOT emit them. Pure Python sentinel cannot exercise these branches without Cinder static-Python infrastructure (not available in this build per theologian 21:32:27Z + supervisor 21:32:42Z fallback). Conversion is mechanical (PyTuple_GET_ITEM extraction + delegate to existing emit functions); structural test exists at Lib/test/test_phoenix_partial_conversions.py:52. Execution-level coverage queued as W-CINDERX-INVOKE-COVERAGE workstream (cinderx_dev integration post-Phoenix-integration). Phase 0' HIR-DIFF planned (theologian step 4): test_exc_raise_catch + 4 W-2A sentinels + Phoenix suite — pre/post conversion HIR comparison to detect any divergence. Verification pending: testkeeper rebuild + 30x all 8 W-2A+W-2B-RECONVERT sentinels + 30x test_multiple_exceptions_in_loop + Phoenix suite + ABBA + dual-arch. Per supervisor 21:32:42Z (post pythia python#140 python#2): full 24-bench ABBA between push 59 (this) and push 60 (emitLoadMethodStatic conversion) — single-commit bisect window for cap-clock at 73 commits since last 24-bench (cbb9453 2026-04-23).
diff --git a/Python/jit/hir/builder.cpp b/Python/jit/hir/builder.cpp
@@ -4,6 +4,7 @@
 #include "cinderx/Jit/hir/hir_instr_c.h"
 #include "cinderx/Jit/hir/hir_c_api.h"
 #include "cinderx/Jit/hir/hir_type_c.h"
+#include "cinderx/Jit/bytecode_c.h"  /* BcByteOffset wrapper for emitAnyCall seam */
 
 extern "C" int hir_remove_trampoline_blocks_c(void *cfg);
 extern "C" int hir_remove_unreachable_blocks_c(void *func);
@@ -2852,77 +2853,26 @@ extern "C" int hir_builder_bc_it_oparg_c(void *bc_it) {
 extern "C" void hir_builder_emit_any_call_c(
     void *tc, void *cfg, void *func, void *builder,
     void *bc_instrs, void *bc_it,
-    int call_kind, int oparg, int base_offset,
-    int is_awaited, int is_kw_arg,
-    void *code, int code_flags,
-    PyObject *const_arg);
+    int opcode, int oparg, BcByteOffset base_offset,
+    void *code, int code_flags);
 
+// W27c full PURE conversion: opcode→PhxCallKind switch + is_awaited check
+// + const_arg extraction all moved to C body. C++ stub is now pure type
+// marshaling delegation; counts as PURE-CONVERTED per W27c #1 emitLoadAttr
+// precedent (98/100 → 99/100 + 1 PARTIAL Cat-B remaining = emitLoadMethodStatic).
 void HIRBuilder::emitAnyCall(
     CFG& cfg,
     TranslationContext& tc,
     jit::BytecodeInstructionBlock::Iterator& bc_it,
     const jit::BytecodeInstructionBlock& bc_instrs) {
   BytecodeInstruction bc_instr = *bc_it;
-  int opcode = bc_instr.opcode();
-  int oparg = bc_instr.oparg();
-  int base_offset = bc_instr.baseOffset().value();
-
-  // Map opcode → PhxCallKind (C body switches on enum to avoid pulling
-  // opcode constants into builder_emit_c.c, where cinder_opcode.h's
-  // Py_OPCODE_H header guard would shadow Include/opcode.h's
-  // BINARY_OP_ADD_INT define + break #ifdef in BINARY_OP specialization).
-  int call_kind;
-  int is_kw_arg = 0;
-  switch (opcode) {
-    case CALL_FUNCTION:
-      call_kind = PHX_CALL_KIND_VECTOR_CALL; break;
-    case CALL_FUNCTION_KW:
-      call_kind = PHX_CALL_KIND_VECTOR_CALL; is_kw_arg = 1; break;
-    case CALL_FUNCTION_EX:
-      call_kind = PHX_CALL_KIND_CALL_EX; break;
-    case CALL:
-    case CALL_METHOD:
-      call_kind = PHX_CALL_KIND_CALL_METHOD; break;
-    case CALL_KW:
-      call_kind = PHX_CALL_KIND_CALL_METHOD; is_kw_arg = 1; break;
-    case INVOKE_FUNCTION:
-      call_kind = PHX_CALL_KIND_INVOKE_FUNCTION; break;
-    case INVOKE_NATIVE:
-      call_kind = PHX_CALL_KIND_INVOKE_NATIVE; break;
-    case INVOKE_METHOD:
-      call_kind = PHX_CALL_KIND_INVOKE_METHOD; break;
-    default:
-      JIT_ABORT("Unhandled call opcode {} ({})", opcode, opcodeName(opcode));
-  }
-
-  int is_awaited;
-  if constexpr (PY_VERSION_HEX >= 0x030C0000) {
-    is_awaited = 0;
-  } else {
-    is_awaited = (code_->co_flags & CO_COROUTINE) &&
-        // We only need to be followed by GET_AWAITABLE to know we are awaited,
-        // but we also need to ensure the following LOAD_CONST and YIELD_FROM
-        // are inside this BytecodeInstructionBlock. This may not be the case if
-        // the 'await' is shared as in 'await (x if y else z)'.
-        bc_it.remainingIndices() >= 3 &&
-        bc_instr.nextInstr().opcode() == GET_AWAITABLE ? 1 : 0;
-  }
-
-  // Pre-extract const_arg for INVOKE_* paths — only used if opcode is one
-  // of INVOKE_FUNCTION/NATIVE/METHOD; NULL otherwise.
-  PyObject *const_arg = nullptr;
-  if (opcode == INVOKE_FUNCTION || opcode == INVOKE_NATIVE
-      || opcode == INVOKE_METHOD) {
-    const_arg = constArg(bc_instr);
-  }
-
   hir_builder_emit_any_call_c(
       &tc, &cfg, current_func_, this,
       const_cast<void*>(static_cast<const void*>(&bc_instrs)),
       &bc_it,
-      call_kind, oparg, base_offset, is_awaited, is_kw_arg,
-      code_, static_cast<int>(code_->co_flags),
-      const_arg);
+      bc_instr.opcode(), bc_instr.oparg(),
+      bc_byte_offset_from_int(bc_instr.baseOffset().value()),
+      code_, static_cast<int>(code_->co_flags));
 }
 
 extern "C" void hir_builder_emit_call_intrinsic_c(void *tc, void *func, int opcode, int oparg);
diff --git a/Python/jit/hir/builder_emit_c.c b/Python/jit/hir/builder_emit_c.c
@@ -3695,20 +3695,92 @@ void hir_builder_emit_any_call_c(
         void *builder,
         void *bc_instrs,
         void *bc_it,
-        int call_kind,        /* PhxCallKind enum (mapped from opcode by C++ stub) */
+        int opcode,            /* W27c full conversion: opcode dispatch C-side */
         int oparg,
-        int base_offset,
-        int is_awaited,
-        int is_kw_arg,        /* set for CALL_FUNCTION_KW + CALL_KW (kwnames flag) */
+        BcByteOffset base_offset,  /* W27c P5: BcByteOffset wrapper (Phase A.5) */
         void *code,
-        int code_flags,
-        PyObject *const_arg) {
-    /* CallFlags: None=0, KwArgs=1<<0=1, Awaited=1<<1=2, Static=1<<2=4.
+        int code_flags) {
+    /* W27c full PURE conversion (post Phase A.5): opcode→PhxCallKind switch,
+     * is_awaited check, and const_arg extraction all moved C-side from the
+     * former C++ stub. base_offset is now BcByteOffset per Phase A.5 P5
+     * wrapper (theologian P7 audit 20:53:51Z). C++ stub at builder.cpp
+     * HIRBuilder::emitAnyCall is now pure type-marshaling delegation
+     * (~12 lines), counts as PURE-CONVERTED per W27c #1 emitLoadAttr
+     * precedent.
+     *
+     * CallFlags: None=0, KwArgs=1<<0=1, Awaited=1<<1=2, Static=1<<2=4.
+     * PHX_CALL_KIND_* values defined in builder.h. */
+
+    /* Map opcode → (call_kind, is_kw_arg). CALL + CALL_FUNCTION_EX from
+     * Include/opcode.h (already included). CALL_FUNCTION/_KW/CALL_KW/
+     * CALL_METHOD from Python/jit_common/opcode_stubs.h (already included,
+     * stubbed >255 in 3.12 but kept in switch for forward compat).
      *
-     * call_kind dispatch (set by C++ stub) replaces direct opcode switching
-     * here so this C body does not need to import opcode constants. The
-     * opcode switch in the C++ stub maps each call-class opcode to one of
-     * the PHX_CALL_KIND_* values (defined in builder.h). */
+     * INVOKE_FUNCTION/NATIVE/METHOD are Cinder-specific opcodes from
+     * Python/jit_interp/3.12/cinder_opcode_ids.h. Local-defined here to
+     * avoid pulling cinder_opcode.h which would shadow Include/opcode.h's
+     * BINARY_OP_ADD_INT define + break #ifdef in BINARY_OP specialization
+     * (per existing comment at line 30). Values (209/216/185) verified
+     * against cinder_opcode_ids.h for 3.12; if cinder INVOKE_* values
+     * change, propagate here. */
+#ifndef INVOKE_FUNCTION
+#define INVOKE_FUNCTION 209
+#endif
+#ifndef INVOKE_NATIVE
+#define INVOKE_NATIVE 216
+#endif
+#ifndef INVOKE_METHOD
+#define INVOKE_METHOD 185
+#endif
+
+    int call_kind;
+    int is_kw_arg = 0;
+    switch (opcode) {
+        case CALL_FUNCTION:
+            call_kind = PHX_CALL_KIND_VECTOR_CALL; break;
+        case CALL_FUNCTION_KW:
+            call_kind = PHX_CALL_KIND_VECTOR_CALL; is_kw_arg = 1; break;
+        case CALL_FUNCTION_EX:
+            call_kind = PHX_CALL_KIND_CALL_EX; break;
+        case CALL:
+        case CALL_METHOD:
+            call_kind = PHX_CALL_KIND_CALL_METHOD; break;
+        case CALL_KW:
+            call_kind = PHX_CALL_KIND_CALL_METHOD; is_kw_arg = 1; break;
+        case INVOKE_FUNCTION:
+            call_kind = PHX_CALL_KIND_INVOKE_FUNCTION; break;
+        case INVOKE_NATIVE:
+            call_kind = PHX_CALL_KIND_INVOKE_NATIVE; break;
+        case INVOKE_METHOD:
+            call_kind = PHX_CALL_KIND_INVOKE_METHOD; break;
+        default:
+            JIT_CHECK_C(0, "Unhandled call opcode %d", opcode);
+            call_kind = PHX_CALL_KIND_VECTOR_CALL;  /* unreachable; silence warn */
+    }
+
+    /* is_awaited: GET_AWAITABLE-tail handling. Per HIRBuilder::emitAnyCall
+     * pre-W27c-PURE C++ stub: 3.12+ doesn't compute this here (returns 0);
+     * older Python checked code->co_flags & CO_COROUTINE + bc_it.nextInstr()
+     * == GET_AWAITABLE. Phoenix targets 3.12 exclusively per memory;
+     * forward-compat for older Python would need C-side bc_it/bc_instr
+     * accessors (out-of-scope for this conversion). */
+#if PY_VERSION_HEX >= 0x030C0000
+    int is_awaited = 0;
+#else
+#  error "is_awaited check needs C-side bc_it accessor for Python < 3.12; \
+not implemented per current 3.12-only target"
+#endif
+
+    /* const_arg = PyTuple_GET_ITEM(code->co_consts, oparg) per
+     * HIRBuilder::constArg @ builder.cpp pre-W27c-PURE. Borrowed ref to
+     * a co_consts entry; no refcount, no GC trigger. Lifetime = code
+     * object = compile duration. Only used for INVOKE_* paths. */
+    PyObject *const_arg = NULL;
+    if (opcode == INVOKE_FUNCTION || opcode == INVOKE_NATIVE
+        || opcode == INVOKE_METHOD) {
+        const_arg = PyTuple_GET_ITEM(((PyCodeObject*)code)->co_consts, oparg);
+    }
+
     uint32_t flags = is_awaited ? 2u : 0u;
     int call_used_is_awaited = 1;
 
@@ -3773,9 +3845,12 @@ void hir_builder_emit_any_call_c(
             /* B2: If this CALL is inside a try block with a simple except pattern,
              * inline the exception handler instead of deopting on exception.
              * Combined per W26 (B) decision: NULL-safe internally — does nothing
-             * if no handler matches OR not simple-pattern. */
+             * if no handler matches OR not simple-pattern.
+             *
+             * base_offset is BcByteOffset (P5 wrapper); unwrap .v at the
+             * boundary to existing raw-int hir_builder_emit_call_method_exception_handler_inline_c API. */
             hir_builder_emit_call_method_exception_handler_inline_c(
-                builder, tc, cfg, base_offset, call, out);
+                builder, tc, cfg, base_offset.v, call, out);
             break;
         }
         case PHX_CALL_KIND_INVOKE_FUNCTION: {
