W26 Step B: emitAnyCall full conversion + 149b7e2 PartialConversion REABSORB

SonicField · SonicField · commit 95c9f9b89102 · 2026-04-22T16:40:23.000-07:00
Per docs/w26-emitanycall-full-conversion.md (push 82) + theologian L2462 + L2466 ((B) folded LITE SPECs design + iterator-bridge architecture). Changes: - Python/jit/hir/builder_emit_c.c: new C body hir_builder_emit_any_call_c (~150 lines). Handles all 5 opcode paths (CALL_FUNCTION/CALL_FUNCTION_KW, CALL_FUNCTION_EX, CALL/CALL_KW/ CALL_METHOD, INVOKE_FUNCTION, INVOKE_NATIVE, INVOKE_METHOD) plus the await-tail dispatch INLINED (149b7e2 PartialConversion bridge body REABSORBED into this C body — the bridge function and REABSORB-WHEN comment block are REMOVED). - Added cinder_opcode.h include BEFORE opcode.h (header-guard ordering issue: both use Py_OPCODE_H, so cinder must come first to define INVOKE_FUNCTION/_NATIVE/_METHOD). - Added opcode_stubs.h for CALL_FUNCTION/CALL_FUNCTION_KW/CALL_KW/ CALL_METHOD/YIELD_FROM (3.10/3.11 opcodes stubbed at >=40000 in 3.12 so case labels remain valid but unreachable on 3.12 codepath). - Python/jit/hir/builder.cpp: HIRBuilder::emitAnyCall becomes a ~30-line C++ stub that: - Extracts opcode/oparg/baseOffset upfront (int values) - Computes is_awaited via in-stub iterator peek + PY_VERSION_HEX conditional - Pre-extracts const_arg for INVOKE_* paths (NULL otherwise) - Delegates to hir_builder_emit_any_call_c with opaque iterator + bytecode block pointers (for in-C-body iterator advancement) Adds 4 NEW C bridges (W26 inventory per theologian L2466): - hir_builder_emit_call_method_exception_handler_inline_c: combined findExceptionHandler + getSimpleExceptInfo + emitCallExceptionHandler (folded per (B) decision; NULL-safe internally) - hir_builder_check_async_with_error_c: bridges static checkAsyncWithError via opaque iterator pointer - hir_builder_bc_it_advance_and_opcode_c: combined ++bc_it + opcode read for await-tail JIT_CHECK sequence - hir_builder_bc_it_oparg_c: read bc_it->oparg() (used once for load_const_oparg) REMOVES: hir_builder_emit_awaited_call_tail_c declaration (was at builder.cpp:2861-2867 with PartialConversion comment); body fully inlined into the await-tail section of hir_builder_emit_any_call_c. - Python/jit/hir/builder.h: extern "C" forward decls for the 4 new bridges + 1 new friend declaration (combined exception-handler bridge needs access to private findExceptionHandler/getSimpleExceptInfo/ emitCallExceptionHandler/code_). W25c-mini compliance per supervisor L2441 refined invariant: - Combined exception-handler bridge: opaque void* params (builder/tc/ cfg/call_instr/result_reg are opaque handles; base_offset is int). - Iterator bridges: opaque void* bc_it/bc_instrs + int return. - All NEW bridges typed at boundaries-with-typed-destinations; void* intermediates allowed within all-void* call chains. Empirical scope-reduction from spec §3 5-bridge estimate to 4 actual NEW bridges (theologian L2466 confirmed): emitVariadic<VectorCall>, emitCallMethod, kwnames_ all covered by EXISTING C primitives (hir_c_create_vectorcall_reg, hir_c_create_call_method_reg, hir_builder_get_kwnames/hir_builder_set_kwnames respectively). Verification: cmake --build target jit/phoenix_jit clean (BUILD_EXIT=0). PartialConversion artifact verified REMOVED: grep "hir_builder_emit_awaited_call_tail_c" Python/jit/hir/*.{c,cpp,h} → 0 declarations + 0 implementations remain (only historical comments explaining the reabsorb action are left).
diff --git a/Python/jit/hir/builder.cpp b/Python/jit/hir/builder.cpp
@@ -2854,163 +2854,108 @@ void HIRBuilder::emitPushNull(TranslationContext& tc) {
   hir_builder_emit_push_null_c(static_cast<void*>(&tc), static_cast<void*>(current_func_));
 }
 
-// PartialConversion (theologian PTE pre-audit chat 2026-04-22 17:15Z):
-// emitAnyCall await-tail dispatch (lines 2963-2993 in pre-conversion source)
-// extracted into C body. Opcode-switch + INVOKE_* dispatch stay C++ until
-// Tier 6 INVOKE_* re-architecture. Bridge spec ratified [chat L1931].
-extern "C" void hir_builder_emit_awaited_call_tail_c(
-    void* tc, void* func, void* builder,
-    PyCodeObject* code,
-    int code_flags,
-    int get_awaitable_error_aenter,
-    int get_awaitable_error_aexit,
-    int load_const_oparg);
-
-// Forward decl — checkAsyncWithError is defined static at builder.cpp:~4856,
-// below the emitAnyCall call site. Pre-PartialConversion the call lived
-// inline within the await-tail; refactor hoisted it above the definition.
+/* W26 (theologian L2462+L2466): emitAnyCall full conversion + 149b7e2d40
+ * PartialConversion REABSORB. The await-tail dispatch is now inlined into
+ * the C body of hir_builder_emit_any_call_c via the iterator + checkAsync
+ * bridges below. The PartialConversion artifact bridge
+ * hir_builder_emit_awaited_call_tail_c is REMOVED; its body lives in the
+ * C body of emit_any_call now. REABSORB-WHEN trigger fired post push 81.
+ *
+ * Forward decl — checkAsyncWithError is defined static at builder.cpp:~4856,
+ * below the emitAnyCall call site. */
 static std::pair<bool, bool> checkAsyncWithError(
     const BytecodeInstructionBlock&, BytecodeInstruction);
 
+extern "C" void hir_builder_emit_call_method_exception_handler_inline_c(
+    void *builder, void *tc, void *cfg, int base_offset,
+    void *call_instr, void *result_reg) {
+  auto *self = static_cast<HIRBuilder*>(builder);
+  BCOffset cur_off{base_offset};
+  const auto *handler = self->findExceptionHandler(cur_off);
+  if (handler == nullptr) {
+    return;
+  }
+  HIRBuilder::SimpleExceptInfo info;
+  if (!self->getSimpleExceptInfo(*handler, info)) {
+    return;
+  }
+  // Reconstruct BytecodeInstruction from base_offset for the C++ method.
+  BytecodeInstruction bc_instr{self->code_, cur_off};
+  self->emitCallExceptionHandler(
+      *static_cast<CFG*>(cfg),
+      *static_cast<HIRBuilder::TranslationContext*>(tc),
+      bc_instr, *handler, info,
+      static_cast<DeoptBase*>(call_instr),
+      static_cast<Register*>(result_reg));
+}
+
+extern "C" void hir_builder_check_async_with_error_c(
+    void *bc_instrs, void *bc_it,
+    int *out_error_aenter, int *out_error_aexit) {
+  auto& it = *static_cast<jit::BytecodeInstructionBlock::Iterator*>(bc_it);
+  auto& bcb = *static_cast<const jit::BytecodeInstructionBlock*>(bc_instrs);
+  auto [aenter, aexit] = checkAsyncWithError(bcb, *it);
+  *out_error_aenter = aenter ? 1 : 0;
+  *out_error_aexit = aexit ? 1 : 0;
+}
+
+extern "C" int hir_builder_bc_it_advance_and_opcode_c(void *bc_it) {
+  auto& it = *static_cast<jit::BytecodeInstructionBlock::Iterator*>(bc_it);
+  ++it;
+  return it->opcode();
+}
+
+extern "C" int hir_builder_bc_it_oparg_c(void *bc_it) {
+  auto& it = *static_cast<jit::BytecodeInstructionBlock::Iterator*>(bc_it);
+  return it->oparg();
+}
+
+extern "C" void hir_builder_emit_any_call_c(
+    void *tc, void *cfg, void *func, void *builder,
+    void *bc_instrs, void *bc_it,
+    int opcode, int oparg, int base_offset,
+    int is_awaited,
+    void *code, int code_flags,
+    PyObject *const_arg);
+
 void HIRBuilder::emitAnyCall(
     CFG& cfg,
     TranslationContext& tc,
     jit::BytecodeInstructionBlock::Iterator& bc_it,
     const jit::BytecodeInstructionBlock& bc_instrs) {
   BytecodeInstruction bc_instr = *bc_it;
-  bool is_awaited;
+  int opcode = bc_instr.opcode();
+  int oparg = bc_instr.oparg();
+  int base_offset = bc_instr.baseOffset().value();
+
+  int is_awaited;
   if constexpr (PY_VERSION_HEX >= 0x030C0000) {
-    is_awaited = false;
+    is_awaited = 0;
   } else {
-    is_awaited = code_->co_flags & CO_COROUTINE &&
+    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;
+        bc_instr.nextInstr().opcode() == GET_AWAITABLE ? 1 : 0;
   }
-  auto flags = is_awaited ? CallFlags::Awaited : CallFlags::None;
-  bool call_used_is_awaited = true;
 
-  auto opcode = bc_instr.opcode();
-  switch (opcode) {
-    case CALL_FUNCTION:
-    case CALL_FUNCTION_KW: {
-      // Operands include the function arguments plus the function itself.
-      auto num_operands = static_cast<std::size_t>(bc_instr.oparg()) + 1;
-      // Add one more operand for the kwnames tuple at the end.
-      if (opcode == CALL_FUNCTION_KW) {
-        num_operands++;
-        flags |= CallFlags::KwArgs;
-      }
-      tc.emitVariadic<VectorCall>(temps_, num_operands, flags);
-      break;
-    }
-    case CALL_FUNCTION_EX: {
-      emitCallEx(tc, bc_instr, flags);
-      break;
-    }
-    case CALL:
-    case CALL_KW:
-    case CALL_METHOD: {
-      auto num_operands = static_cast<std::size_t>(bc_instr.oparg()) + 2;
-      auto num_stack_inputs = num_operands;
-      bool is_call_kw = opcode == CALL_KW;
-      if (kwnames_ != nullptr || is_call_kw) {
-        if (is_call_kw) {
-          num_stack_inputs++;
-        }
-        num_operands++;
-        flags |= CallFlags::KwArgs;
-      }
-
-      // Manually set up the instruction instead of using emitVariadic.
-      // kwnames_ isn't on the stack, but it has to be part of the operand
-      // count.
-      Register* out = temps_.AllocateStack();
-      auto call = tc.emitCallMethod(num_operands, out, flags);
-      for (auto i = num_stack_inputs; i > 0; i--) {
-        Register* arg = static_cast<Register*>(phx_ptr_arr_pop(&tc.frame.stack));
-        call->SetOperand(i - 1, arg);
-      }
-      if (kwnames_ != nullptr) {
-        JIT_CHECK(
-            call->GetOperand(num_operands - 1) == nullptr,
-            "Somehow already set the kwnames argument");
-        call->SetOperand(num_operands - 1, kwnames_);
-        kwnames_ = nullptr;
-      }
-      call->setFrameState(tc.frame);
-
-      phx_ptr_arr_push(&tc.frame.stack, out);
-
-      // B2: If this CALL is inside a try block with a simple except pattern,
-      // inline the exception handler instead of deopting on exception.
-      // This prevents the deopt cascade that occurs when JIT-compiled
-      // functions raise caught exceptions (e.g. StopIteration from next()
-      // in contextlib._GeneratorContextManager.__exit__).
-      {
-        BCOffset cur_off = bc_instr.baseOffset();
-        auto* handler = findExceptionHandler(cur_off);
-        if (handler != nullptr) {
-          SimpleExceptInfo info;
-          if (getSimpleExceptInfo(*handler, info)) {
-            emitCallExceptionHandler(
-                cfg, tc, bc_instr, *handler, info, call, out);
-          }
-        }
-      }
-      break;
-    }
-    case INVOKE_FUNCTION: {
-      call_used_is_awaited = emitInvokeFunction(tc, bc_instr, flags);
-      break;
-    }
-    case INVOKE_NATIVE: {
-      call_used_is_awaited = emitInvokeNative(tc, bc_instr);
-      break;
-    }
-    case INVOKE_METHOD: {
-      call_used_is_awaited = emitInvokeMethod(tc, bc_instr, is_awaited);
-      break;
-    }
-    default:
-      JIT_ABORT("Unhandled call opcode {} ({})", opcode, opcodeName(opcode));
-  }
-  if (is_awaited && call_used_is_awaited) {
-    // (D1+A4) Advance bc_it three times + assert opcode sequence on the C++
-    // side BEFORE the C body runs. Iterator state never crosses the boundary
-    // (PB invariant) — only int baseOffsets/oparg/error flags pass through.
-    ++bc_it;
-    JIT_CHECK(
-        bc_it->opcode() == GET_AWAITABLE,
-        "Awaited function call must be followed by GET_AWAITABLE");
-    auto get_awaitable_bc = *bc_it;
-    auto [error_aenter, error_aexit] =
-        checkAsyncWithError(bc_instrs, get_awaitable_bc);
-
-    ++bc_it;
-    JIT_CHECK(
-        bc_it->opcode() == LOAD_CONST,
-        "GET_AWAITABLE must be followed by LOAD_CONST");
-    int load_const_oparg = bc_it->oparg();
-
-    ++bc_it;
-    JIT_CHECK(
-        bc_it->opcode() == YIELD_FROM,
-        "GET_AWAITABLE should always be followed by LOAD_CONST+YIELD_FROM");
-
-    hir_builder_emit_awaited_call_tail_c(
-        static_cast<void*>(&tc),
-        static_cast<void*>(current_func_),
-        static_cast<void*>(this),
-        code_,
-        static_cast<int>(code_->co_flags),
-        static_cast<int>(error_aenter),
-        static_cast<int>(error_aexit),
-        load_const_oparg);
+  // 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,
+      opcode, oparg, base_offset, is_awaited,
+      code_, static_cast<int>(code_->co_flags),
+      const_arg);
 }
 
 extern "C" void hir_builder_emit_call_intrinsic_c(void *tc, void *func, int opcode, int oparg);
diff --git a/Python/jit/hir/builder.h b/Python/jit/hir/builder.h
@@ -41,6 +41,19 @@ void hir_builder_setup_static_args_c(
     void **out_arg_regs, size_t *out_count);
 void *hir_builder_static_method_stack_pop_c(void *builder);
 
+/* W26 (theologian L2462+L2466): bridges for emitAnyCall full conversion +
+ * 149b7e2d40 PartialConversion reabsorb. 4 NEW bridges: combined exception-
+ * handler emit (folds findExceptionHandler+getSimpleExceptInfo+emit per (B)
+ * decision), checkAsyncWithError, bc_it advance+opcode, bc_it oparg. */
+void hir_builder_emit_call_method_exception_handler_inline_c(
+    void *builder, void *tc, void *cfg, int base_offset,
+    void *call_instr, void *result_reg);
+void hir_builder_check_async_with_error_c(
+    void *bc_instrs, void *bc_it,
+    int *out_error_aenter, int *out_error_aexit);
+int hir_builder_bc_it_advance_and_opcode_c(void *bc_it);
+int hir_builder_bc_it_oparg_c(void *bc_it);
+
 /* INVOKE_* Phase 2 #3 (theologian L2430): bridges for emitInvokeFunction C
  * body. Function-target variants of #2 bridges (different preloader lookup
  * path: invokeFunctionTarget vs invokeMethodTarget) + invoke-target query +
@@ -169,6 +182,11 @@ class HIRBuilder {
       void*, void*, PyObject*, long, int, void**, size_t*);
   friend int ::hir_builder_is_static_rand_and_try_emit_c(
       void*, void*, PyObject*, long);
+  // W26 (theologian L2462+L2466): emitAnyCall full conversion + 149b7e2d40
+  // reabsorb. Friends grant private-member access (exception_table_,
+  // findExceptionHandler, getSimpleExceptInfo, emitCallExceptionHandler).
+  friend void ::hir_builder_emit_call_method_exception_handler_inline_c(
+      void*, void*, void*, int, void*, void*);
  public:
   const Preloader& preloader() const { return preloader_; }
   explicit HIRBuilder(const Preloader& preloader)
diff --git a/Python/jit/hir/builder_emit_c.c b/Python/jit/hir/builder_emit_c.c
