simplify: fix output type bug + add hir_output_type bridge

Root cause: simplify_env_emit was not setting output register types,
causing 'new output type TTop isn't compatible with old output type'
assertion failures.

Fix: added hir_output_type C bridge (wraps C++ outputType) and
integrated into simplify_env_emit. All emitted instructions now get
correct output types automatically, mirroring C++ emitCInstr.

Also reverted Float/Long/Bool comparison paths from Compare handler
(need to re-verify with outputType bridge before re-adding).
Added LoadVarObjectSize known-object path.

Author: SonicField

Python/jit/hir/hir_c_api.cpp

@@ -466,6 +466,10 @@ void hir_reg_uses_destroy(HirRegUses uses) {
 
 /* ---- outputType with override ---- */
 
+HirType hir_output_type(HirInstr instr) {
+  return Type::toHirType(outputType(*as_instr(instr)));
+}
+
 HirType hir_output_type_with_override(HirInstr instr,
                                       size_t override_idx,
                                       const HirType *override_type) {

Python/jit/hir/hir_c_api.h

@@ -624,7 +624,10 @@ HirInstr hir_reg_uses_get(HirRegUses uses, HirRegister reg, size_t idx);
 /* Free the RegUses handle. */
 void hir_reg_uses_destroy(HirRegUses uses);
 
-/* ---- outputType with override ---- */
+/* ---- outputType ---- */
+
+/* Compute the output type of an instruction based on its opcode and operands. */
+HirType hir_output_type(HirInstr instr);
 
 /* Compute the output type of an instruction, but override one operand's
  * type at override_idx with override_type. Used by guard removal to

Python/jit/hir/simplify.cpp

@@ -2797,8 +2797,13 @@ Register* simplifyInstr(Env& env, const Instr* instr) {
     case Opcode::kLoadArrayItem:
       return simplifyLoadArrayItem(
           env, static_cast<const LoadArrayItem*>(instr));
-    case Opcode::kLoadVarObjectSize:
+    case Opcode::kLoadVarObjectSize: {
+      SimplifyEnv cenv = make_c_env();
+      auto *r = static_cast<Register*>(simplify_load_var_object_size_c(&cenv, instr));
+      sync_c_env(cenv);
+      if (r) return r;
       return simplifyLoadVarObjectSize(env, instr);
+    }
 
     case Opcode::kBinaryOp:
       return simplifyBinaryOp(env, static_cast<const BinaryOp*>(instr));

Python/jit/hir/simplify_c.c

@@ -12,14 +12,20 @@
 extern HirType hir_register_type(void *reg);
 extern void *hir_func_alloc_register(void *func);
 extern void hir_c_insert_before(void *new_instr, void *before);
+extern HirType hir_output_type(void *instr);
 
 /* ---- SimplifyEnv: C equivalent of the C++ Env struct ---- */
 
 void *simplify_env_emit(SimplifyEnv *env, void *new_instr) {
     env->optimized = 1;
     hir_c_set_bytecode_offset(new_instr, env->bc_off);
     hir_c_insert_before(new_instr, env->cursor_instr);
-    return hir_c_output(new_instr);
+    void *out = hir_c_output(new_instr);
+    if (out) {
+        HirType out_type = hir_output_type(new_instr);
+        hir_reg_set_type(out, out_type);
+    }
+    return out;
 }
 
 void *simplify_env_emit_load_const(SimplifyEnv *env, HirType type) {
@@ -157,36 +163,6 @@ void *simplify_compare_c(SimplifyEnv *env, const void *instr) {
         }
     }
 
-    /* Bool == Bool or Bool != Bool → PrimitiveCompare + PrimitiveBoxBool */
-    HirType t_bool = HIR_TYPE_SIMPLE(0x00000000002ULL, HIR_TYPE_LIFETIME_TOP);
-    if (hir_type_is_subtype(left_type, t_bool) &&
-        hir_type_is_subtype(right_type, t_bool) &&
-        (op == 2 || op == 3)) {
-        /* PrimitiveCompareOp::kEqual=4, kNotEqual=5 match CompareOp values */
-        int32_t prim_op = (op == 2) ? 4 : 5;
-        simplify_env_emit_use_type(env, left, t_bool);
-        simplify_env_emit_use_type(env, right, t_bool);
-        void *result = simplify_env_emit_primitive_compare(env, prim_op, left, right);
-        return simplify_env_emit_primitive_box_bool(env, result);
-    }
-
-    HirType t_float_exact = HIR_TYPE_SIMPLE(0x00000008000ULL, HIR_TYPE_LIFETIME_TOP);
-    HirType t_long_exact = HIR_TYPE_SIMPLE(0x00000010000ULL, HIR_TYPE_LIFETIME_TOP);
-
-    /* Float comparison */
-    if (hir_type_is_subtype(left_type, t_float_exact) &&
-        hir_type_is_subtype(right_type, t_float_exact) &&
-        op != 6 && op != 7 && op != 10) { /* not In/NotIn/ExcMatch */
-        return simplify_env_emit_float_compare(env, op, left, right);
-    }
-
-    /* Long comparison */
-    if (hir_type_is_subtype(left_type, t_long_exact) &&
-        hir_type_is_subtype(right_type, t_long_exact) &&
-        op != 6 && op != 7 && op != 10) {
-        return simplify_env_emit_long_compare(env, op, left, right);
-    }
-
     return NULL;
 }
 
@@ -203,6 +179,28 @@ void *simplify_int_convert_c(SimplifyEnv *env, const void *instr) {
     return NULL;
 }
 
+/* ---- simplifyLoadVarObjectSize (partial — known object path) ----
+ * If input is a known tuple/bytes object, fold to constant ob_size. */
+void *simplify_load_var_object_size_c(SimplifyEnv *env, const void *instr) {
+    void *obj_reg = hir_c_get_operand(instr, 0);
+    HirType obj_type = hir_register_type(obj_reg);
+
+    HirType t_tuple_exact = HIR_TYPE_SIMPLE(0x00000040000ULL, HIR_TYPE_LIFETIME_TOP);
+    HirType t_bytes_exact = HIR_TYPE_SIMPLE(0x00000002000ULL, HIR_TYPE_LIFETIME_TOP);
+
+    if (hir_type_has_value_spec(&obj_type, t_tuple_exact) ||
+        hir_type_has_value_spec(&obj_type, t_bytes_exact)) {
+        PyObject *obj = hir_type_as_object(&obj_type);
+        if (obj != NULL) {
+            Py_ssize_t size = ((PyVarObject *)obj)->ob_size;
+            simplify_env_emit_use_type(env, obj_reg, obj_type);
+            HirType output_type = hir_register_type(hir_c_output(instr));
+            return simplify_env_emit_load_const(env, make_cint_type(output_type, (intptr_t)size));
+        }
+    }
+    return NULL;
+}
+
 /* ---- simplifyIsNegativeAndErrOccurred ----
  * If input is a LoadConst, we know no exception is active → result is 0. */
 void *simplify_is_neg_and_err_c(SimplifyEnv *env, const void *instr) {

Python/jit/hir/simplify_c.h

@@ -37,6 +37,7 @@ void *simplify_cint_to_cbool_c(SimplifyEnv *env, const void *instr);
 void *simplify_cond_branch_const_c(SimplifyEnv *env, const void *instr);
 void *simplify_compare_c(SimplifyEnv *env, const void *instr);
 void *simplify_is_neg_and_err_c(SimplifyEnv *env, const void *instr);
+void *simplify_load_var_object_size_c(SimplifyEnv *env, const void *instr);
 
 #ifdef __cplusplus
 }