builder: emitCallExceptionHandler → C orchestrator (W27c #2b Cat B)

SonicField · SonicField · commit 7329403d0f06 · 2026-04-25T09:58:30.000-07:00
Per theologian W27c pair-batch design 00:08:52Z + 16:57:48Z APPROVE; supervisor (α) local-accumulate posture. Conversion #2b in the 5-method PARTIAL backlog (now 3 → 2 PARTIAL Cat-B remaining); pair-batch sibling of W27c #2a (7135d94). Cat B residue elimination — pair-batch closure: this commit mirrors W27c #2a emitInlineExceptionMatch's shape and reuses the same C helper build_inline_except_opcode_array_c (introduced in #2a). The pre-resolve loop that previously ran on the C++ side (BytecodeInstruction iteration + PyTuple_GET_ITEM(co_consts) for LOAD_CONST/RETURN_CONST + getBlockAtOff for JUMP_BACKWARD* + the terminator-detection skip-list) is deleted C++-side and replaced with a single helper invocation in the C body. Signature change: hir_builder_emit_call_exception_handler_c drops (opcodes, opcode_count) params; builds opcode array internally from PyCodeObject (via tc->frame.code) + builder block_map + except_body_offset, identical to the #2a entry path. C++ stub shrinks from ~70 lines to ~25. D1 pre-amble (call_instr->setSuppressExceptionDeopt(true) + phx_ptr_arr_pop on tc.frame.stack) stays C++-side because DeoptBase*/Register* are C++-only types — that boundary is intentional and unchanged. D3 ok-block sequence (RefineType in-place SSA-rename + push result back to outer tc stack to undo emitAnyCall's pre-amble pop) preserved verbatim. Bridge-struct elimination (bonus cleanup): with both #2a and #2b now C-side for opcode-array construction, the C++/C bridge struct OpcodeArrayEntry_CXX (+ its static_assert) in builder.cpp has zero remaining references. Deleted entirely. The C-side OpcodeArrayEntry struct in builder_emit_c.c stays (still used by emit_except_match_body_c). This realises the design intent stated in W27c #2a's commit message ("Eliminates OpcodeArrayEntry C++/C bridge struct entirely"). Honest ratio framing per librarian D-1776879377 / D-1776880214: post-conversion 98/100 PURE-CONVERTED + 2 PARTIAL Cat-B remaining (was 97/100 + 3 PARTIAL after W27c #2a). emitCallExceptionHandler is now a delegation stub, not pure-C++-eliminated; same metric reading as the established honest-scope record. Remaining 2 PARTIAL are emitAnyCall (await-tail residue, design-residual per pythia python#128 D-1777029012) and emitLoadMethodStatic (classloader.h _PyType_VTable struct dependency, design-residual per A1 rule). VERIFICATION: deferred to testkeeper full gate cycle (post-reboot fresh verifications per supervisor 16:54:08Z stale-pre-reboot discipline). All pre-reboot results (testkeeper 00:48:33Z + 01:45:23Z + 05:39:16Z) RETIRED. Push 54 batch (W27c python#1 7bfb7d1 + #2a 7135d94 + this commit) gated on: - x86_64 fresh build + JIT smoke + nbody + W-RE-PARSER substrate-stability + Phoenix CPython suite + ABBA 4-bench - ARM64 STRICT verify on 3-commit bundle (devgpu004 connectivity restored 16:53Z post-server-reboot) - gatekeeper APPROVE - supervisor PUSH AUTHORIZED Auth chain: theologian design 00:08:52Z + APPROVE 16:57:48Z; supervisor (α) authorization 00:07:10Z + 16:55:47Z plan; testkeeper standby for fresh full gate (post-reboot discipline).
diff --git a/Python/jit/hir/builder.cpp b/Python/jit/hir/builder.cpp
@@ -1326,18 +1326,10 @@ bool HIRBuilder::getSimpleExceptInfo(
   return true;
 }
 
-// OpcodeArrayEntry — mirror of the C-side struct in builder_emit_c.c.
-// 5 fields per entry. Layout MUST match (verified via static_assert).
-struct OpcodeArrayEntry_CXX {
-  int opcode;
-  int oparg;
-  int base_offset;
-  void* const_obj;
-  void* jump_target_block;
-};
-static_assert(sizeof(OpcodeArrayEntry_CXX) <= 64,
-              "OpcodeArrayEntry size sanity");
-
+// W27c #2a + #2b: OpcodeArrayEntry C++/C bridge struct eliminated. The
+// pre-resolve loop now runs entirely C-side via
+// build_inline_except_opcode_array_c in builder_emit_c.c, sharing the
+// helper between emitInlineExceptionMatch and emitCallExceptionHandler.
 extern "C" void hir_builder_emit_inline_exception_match_c(
     void* tc, void* func, void* builder,
     int bc_base_offset,
@@ -1391,9 +1383,7 @@ extern "C" void hir_builder_emit_call_exception_handler_c(
     int except_body_offset,
     HirType return_type,
     void* result,
-    void* match_and_clear_fn,
-    const OpcodeArrayEntry_CXX* opcodes,
-    size_t opcode_count);
+    void* match_and_clear_fn);
 
 void HIRBuilder::emitCallExceptionHandler(
     CFG& /*cfg*/,
@@ -1409,46 +1399,12 @@ void HIRBuilder::emitCallExceptionHandler(
   //      preserved for Simplify, register allocation, other deopt paths.
   //   2. Pop the result that emitAnyCall pushed onto the stack — the C
   //      body's deopt path expects a clean stack at the CALL offset.
+  // W27c #2b: pre-resolve opcode array now built C-side via
+  // build_inline_except_opcode_array_c (shared with W27c #2a
+  // emitInlineExceptionMatch).
   call_instr->setSuppressExceptionDeopt(true);
   static_cast<Register*>(phx_ptr_arr_pop(&tc.frame.stack));
 
-  // Build OpcodeArray identical-shape to emitInlineExceptionMatch — the
-  // dispatch loop in the shared C helper expects this layout. Pre-resolves
-  // const_obj (LOAD_CONST/RETURN_CONST) + jump_target_block (JUMP_BACKWARD*)
-  // to keep PyCodeObject + getBlockAtOff access on the C++ side.
-  std::vector<OpcodeArrayEntry_CXX> opcodes;
-  BytecodeInstruction ebc{code_, info.except_body};
-  bool emitted_terminator = false;
-  while (!emitted_terminator) {
-    OpcodeArrayEntry_CXX entry{
-        ebc.opcode(),
-        ebc.oparg(),
-        ebc.baseOffset().value(),
-        nullptr,
-        nullptr};
-    int op = entry.opcode;
-    if (op == LOAD_CONST || op == RETURN_CONST) {
-      entry.const_obj = PyTuple_GET_ITEM(code_->co_consts, entry.oparg);
-    }
-    if (op == JUMP_BACKWARD || op == JUMP_BACKWARD_NO_INTERRUPT) {
-      entry.jump_target_block =
-          static_cast<void*>(getBlockAtOff(ebc.getJumpTarget()));
-    }
-    if (op == RETURN_VALUE || op == RETURN_CONST
-        || op == JUMP_BACKWARD || op == JUMP_BACKWARD_NO_INTERRUPT) {
-      emitted_terminator = true;
-    } else if (op != POP_EXCEPT && op != POP_TOP && op != SWAP
-               && op != LOAD_FAST && op != LOAD_FAST_CHECK
-               && op != LOAD_FAST_AND_CLEAR && op != LOAD_CONST
-               && op != STORE_FAST && op != BINARY_OP) {
-      emitted_terminator = true;
-    }
-    opcodes.push_back(entry);
-    if (!emitted_terminator) {
-      ebc = ebc.nextInstr();
-    }
-  }
-
   hir_builder_emit_call_exception_handler_c(
       static_cast<void*>(&tc),
       static_cast<void*>(current_func_),
@@ -1459,9 +1415,7 @@ void HIRBuilder::emitCallExceptionHandler(
       info.except_body.value(),
       Type::toHirType(preloader_.returnType()),
       static_cast<void*>(result),
-      reinterpret_cast<void*>(JITRT_MatchAndClearException),
-      opcodes.data(),
-      opcodes.size());
+      reinterpret_cast<void*>(JITRT_MatchAndClearException));
 }
 
 BasicBlock* HIRBuilder::getBlockAtOff(BCOffset off) {
diff --git a/Python/jit/hir/builder_emit_c.c b/Python/jit/hir/builder_emit_c.c
@@ -3568,15 +3568,23 @@ void hir_builder_emit_call_exception_handler_c(
         int except_body_offset,
         HirType return_type,
         void *result,
-        void *match_and_clear_fn,
-        const OpcodeArrayEntry *opcodes,
-        size_t opcode_count) {
+        void *match_and_clear_fn) {
     HirType t_object = HIR_TYPE_OBJECT;
 
     /* (D1) Pre-amble (setSuppressExceptionDeopt + pop result) is done on
      * the C++ stub side BEFORE this C body — see builder.cpp emitter.
      * The C body's first action is the ok/exc branch on result. */
 
+    /* W27c #2b: pre-resolve opcode array C-side (was C++ stub). Shares
+     * the helper with hir_builder_emit_inline_exception_match_c (W27c #2a).
+     * code accessible via tc->frame.code (set by frame init in
+     * hir_builder_state_emit_phase). */
+    OpcodeArrayEntry *opcodes = NULL;
+    size_t opcode_count = 0;
+    build_inline_except_opcode_array_c(
+        (PyCodeObject*)tc->frame.code, builder, except_body_offset,
+        &opcodes, &opcode_count);
+
     void *ok_block = hir_cfg_alloc_block(func);
     void *exc_match_block = hir_cfg_alloc_block(func);
     phx_tc_emit(tc, hir_c_create_cond_branch_cpp(result, ok_block, exc_match_block));
@@ -3597,6 +3605,8 @@ void hir_builder_emit_call_exception_handler_c(
     tc->block = ok_block;
     phx_tc_emit(tc, hir_c_create_refine_type_reg(result, t_object, result));
     phx_ptr_arr_push(&tc->frame.stack, result);
+
+    PyMem_RawFree(opcodes);
 }
 
 /* emitAnyCall full conversion — W26 (theologian L2462+L2466).
