#ifdef ANT_JIT

#include <math.h>
#include "silver/glue.h"

#include "utf8.h"
#include "internal.h"
#include "errors.h"

#include "ops/globals.h"
#include "ops/property.h"
#include "ops/iteration.h"
#include "ops/upvalues.h"
#include "ops/comparison.h"
#include "ops/calls.h"

bool jit_helper_stack_overflow(ant_t *js) {
  volatile char marker;
  uintptr_t curr = (uintptr_t)&marker;
  if (js->cstk.limit == 0 || js->cstk.base == NULL) return false;
  uintptr_t base = (uintptr_t)js->cstk.base;
  size_t used = (base > curr) ? (base - curr) : (curr - base);
  return used > js->cstk.limit;
}

ant_value_t jit_helper_stack_overflow_error(sv_vm_t *vm, ant_t *js) {
  return js_mkerr_typed(js, JS_ERR_RANGE | JS_ERR_NO_STACK, "Maximum JIT call stack size exceeded");
}

ant_value_t jit_helper_add(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) + tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_sub(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) - tod(r));
  if ((vtype(l) == T_NUM || vtype(l) == T_STR) && (vtype(r) == T_NUM || vtype(r) == T_STR)) {
    double ld = (vtype(l) == T_NUM) ? tod(l) : js_to_number(js, l);
    double rd = (vtype(r) == T_NUM) ? tod(r) : js_to_number(js, r);
    return tov(ld - rd);
  }
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_mul(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) * tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_div(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(tod(l) / tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_mod(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return tov(fmod(tod(l), tod(r)));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_str_append_local(
  sv_vm_t *vm, ant_t *js, sv_func_t *func,
  ant_value_t *args, int argc,
  ant_value_t *locals, uint16_t slot_idx,
  ant_value_t rhs
) {
  if (!func)
    return SV_JIT_BAILOUT;

  sv_frame_t frame = {
    .func = func,
    .bp = args,
    .lp = locals,
    .argc = argc,
    .arguments_obj = js_mkundef(),
  };

  return sv_string_builder_append_slot(vm, js, &frame, func, slot_idx, rhs);
}

ant_value_t jit_helper_str_append_local_snapshot(
  sv_vm_t *vm, ant_t *js, sv_func_t *func,
  ant_value_t *args, int argc,
  ant_value_t *locals, uint16_t slot_idx,
  ant_value_t lhs, ant_value_t rhs
) {
  if (!func)
    return SV_JIT_BAILOUT;

  sv_frame_t frame = {
    .func = func,
    .bp = args,
    .lp = locals,
    .argc = argc,
    .arguments_obj = js_mkundef(),
  };

  return sv_string_builder_append_snapshot_slot(vm, js, &frame, func, slot_idx, lhs, rhs);
}

ant_value_t jit_helper_str_flush_local(
  sv_vm_t *vm, ant_t *js, sv_func_t *func,
  ant_value_t *args, int argc,
  ant_value_t *locals, uint16_t slot_idx
) {
  if (!func)
    return SV_JIT_BAILOUT;

  sv_frame_t frame = {
    .func = func,
    .bp = args,
    .lp = locals,
    .argc = argc,
    .arguments_obj = js_mkundef(),
  };

  ant_value_t flush = sv_string_builder_flush_slot(vm, js, &frame, slot_idx);
  if (is_err(flush)) return flush;
  return js_mkundef();
}

ant_value_t jit_helper_lt(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return js_bool(tod(l) < tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_le(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM) return js_bool(tod(l) <= tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_call(
  sv_vm_t *vm, ant_t *js,
  ant_value_t func, ant_value_t this_val,
  ant_value_t *args, int argc
) {
  return sv_vm_call(vm, js, func, this_val, args, argc, NULL, false);
}

ant_value_t jit_helper_call_method(
  sv_vm_t *vm, ant_t *js,
  ant_value_t func, ant_value_t this_val,
  ant_value_t *args, int argc,
  ant_value_t super_val, ant_value_t new_target,
  ant_value_t *out_this
) {
  bool is_super_call = (vtype(super_val) != T_UNDEF && func == super_val);
  ant_value_t call_this = this_val;

  if (is_super_call) js->new_target = new_target;

  ant_value_t super_this = call_this;
  ant_value_t result = sv_vm_call(
    vm, js, func, call_this, args, argc,
    is_super_call ? &super_this : NULL, is_super_call
  );

  if (out_this) {
    if (is_super_call && !is_err(result)) *out_this = is_object_type(result) ? result : super_this;
    else *out_this = call_this;
  }

  return result;
}

ant_value_t jit_helper_apply(
  sv_vm_t *vm, ant_t *js,
  ant_value_t func, ant_value_t this_val,
  ant_value_t *args, int argc
) {
  sv_call_args_t call;
  sv_call_args_reset(&call, args, argc);
  ant_value_t norm = sv_apply_normalize_args(js, &call);
  if (is_err(norm)) return norm;
  ant_value_t result = sv_vm_call(vm, js, func, this_val, call.args, call.argc, NULL, false);
  sv_call_args_release(&call);
  return result;
}

ant_value_t jit_helper_rest(
  sv_vm_t *vm, ant_t *js,
  ant_value_t *args, int argc, int start
) {
  ant_value_t arr = js_mkarr(js);
  for (int i = start; i < argc; i++)
    js_arr_push(js, arr, args[i]);
  return arr;
}

ant_value_t jit_helper_get_global(
  ant_t *js, const char *str,
  sv_func_t *func, int32_t bc_off
) {
  uint8_t *ip = NULL;
  if (func && bc_off >= 0 && bc_off < func->code_len) ip = func->code + bc_off;
  return sv_global_get_interned_ic(js, str, func, ip);
}

ant_value_t jit_helper_special_obj(sv_vm_t *vm, ant_t *js, uint32_t which) {
  if (which == 1) return sv_vm_get_new_target(vm, js);
  if (which == 2) return sv_vm_get_super_val(vm);
  if (which == 3) return js_get_module_import_binding(js);
  return js_mkundef();
}

void jit_helper_define_method_comp(
  ant_t *js,
  ant_value_t obj, ant_value_t key, ant_value_t fn, uint8_t flags
) {
  ant_value_t desc_obj = js_as_obj(obj);
  bool is_getter = (flags & 1) != 0;
  bool is_setter = (flags & 2) != 0;
  if (vtype(key) == T_SYMBOL) {
    if (is_getter) { js_set_sym_getter_desc(js, desc_obj, key, fn, JS_DESC_E | JS_DESC_C); return; }
    if (is_setter) { js_set_sym_setter_desc(js, desc_obj, key, fn, JS_DESC_E | JS_DESC_C); return; }
    js_set_sym(js, obj, key, fn);
    return;
  }
  ant_value_t key_str = sv_key_to_propstr(js, key);
  if ((is_getter || is_setter) && vtype(key_str) == T_STR) {
    ant_offset_t klen = 0;
    ant_offset_t koff = vstr(js, key_str, &klen);
    const char *kptr = (const char *)(uintptr_t)(koff);
    if (is_getter) js_set_getter_desc(js, desc_obj, kptr, klen, fn, JS_DESC_E | JS_DESC_C);
    else js_set_setter_desc(js, desc_obj, kptr, klen, fn, JS_DESC_E | JS_DESC_C);
    return;
  }
  if (vtype(key_str) == T_STR) {
    ant_offset_t klen = 0;
    ant_offset_t koff = vstr(js, key_str, &klen);
    const char *kptr = (const char *)(uintptr_t)(koff);
    js_define_own_prop(js, obj, kptr, (size_t)klen, fn);
  } else mkprop(js, obj, key_str, fn, 0);
}

static ant_value_t jit_iter_advance_from_buf(
  sv_vm_t *vm, ant_t *js, ant_value_t *iter_buf, int hint,
  ant_value_t *out_value, bool *out_done
) {
  GC_ROOT_SAVE(root_mark, js);

  int tag = hint ? hint : (int)js_getnum(iter_buf[2]);
  switch (tag) {
  case SV_ITER_ARRAY: {
    ant_value_t arr = iter_buf[0];
    GC_ROOT_PIN(js, arr);
    int idx = (int)js_getnum(iter_buf[1]);
    ant_offset_t len = js_arr_len(js, arr);
    if (idx >= (int)len) {
      *out_value = js_mkundef();
      *out_done = true;
    } else {
      *out_value = js_arr_get(js, arr, (ant_offset_t)idx);
      *out_done = false;
      iter_buf[1] = tov(idx + 1);
    }
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  case SV_ITER_MAP: {
    map_iterator_state_t *st = (map_iterator_state_t *)(uintptr_t)js_getnum(iter_buf[0]);
    if (!st->current) {
      *out_value = js_mkundef();
      *out_done = true;
    } else {
      map_entry_t *entry = st->current;
      ant_value_t value;
      switch (st->type) {
      case ITER_TYPE_MAP_VALUES:
        value = entry->value;
        break;
      case ITER_TYPE_MAP_KEYS:
        value = entry->key_val;
        break;
      case ITER_TYPE_MAP_ENTRIES: {
        ant_value_t pair = js_mkarr(js);
        js_arr_push(js, pair, entry->key_val);
        js_arr_push(js, pair, entry->value);
        value = pair;
        break;
      }
      default:
        value = js_mkundef();
      }
      st->current = entry->hh.next;
      *out_value = value;
      *out_done = false;
    }
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  case SV_ITER_SET: {
    set_iterator_state_t *st = (set_iterator_state_t *)(uintptr_t)js_getnum(iter_buf[0]);
    if (!st->current) {
      *out_value = js_mkundef();
      *out_done = true;
    } else {
      set_entry_t *entry = st->current;
      ant_value_t value;
      if (st->type == ITER_TYPE_SET_ENTRIES) {
        ant_value_t pair = js_mkarr(js);
        js_arr_push(js, pair, entry->value);
        js_arr_push(js, pair, entry->value);
        value = pair;
      } else {
        value = entry->value;
      }
      st->current = entry->hh.next;
      *out_value = value;
      *out_done = false;
    }
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  case SV_ITER_STRING: {
    ant_value_t str = iter_buf[0];
    GC_ROOT_PIN(js, str);
    int idx = (int)js_getnum(iter_buf[1]);
    ant_offset_t slen = str_len_fast(js, str);
    if (idx >= (int)slen) {
      *out_value = js_mkundef();
      *out_done = true;
    } else {
      ant_offset_t off = vstr(js, str, NULL);
      utf8proc_int32_t cp;
      ant_offset_t cb_len = (ant_offset_t)utf8_next(
        (const utf8proc_uint8_t *)(uintptr_t)(off + idx),
        (utf8proc_ssize_t)(slen - idx),
        &cp
      );
      *out_value = js_mkstr(js, (const void *)(uintptr_t)(off + idx), cb_len);
      *out_done = false;
      iter_buf[1] = tov(idx + (int)cb_len);
    }
    GC_ROOT_PIN(js, *out_value);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  default: {
    ant_value_t iterator = iter_buf[0];
    ant_value_t next_method = iter_buf[1];
    GC_ROOT_PIN(js, iterator);
    GC_ROOT_PIN(js, next_method);
    if (!is_callable(next_method)) {
      GC_ROOT_RESTORE(js, root_mark);
      return js_mkerr(js, "iterator.next is not a function");
    }
    ant_value_t result = sv_vm_call(vm, js, next_method, iterator, NULL, 0, NULL, false);
    if (is_err(result)) {
      GC_ROOT_RESTORE(js, root_mark);
      return result;
    }
    GC_ROOT_PIN(js, result);
    if (!is_object_type(result)) {
      GC_ROOT_RESTORE(js, root_mark);
      return js_mkerr_typed(js, JS_ERR_TYPE, "Iterator result is not an object");
    }
    ant_value_t done = js_mkundef();
    GC_ROOT_PIN(js, done);
    sv_iter_result_unpack(js, result, &done, out_value);
    GC_ROOT_PIN(js, *out_value);
    if (is_err(done)) {
      GC_ROOT_RESTORE(js, root_mark);
      return done;
    }
    if (is_err(*out_value)) {
      GC_ROOT_RESTORE(js, root_mark);
      return *out_value;
    }
    *out_done = js_truthy(js, done);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }}
}

void jit_helper_destructure_close(
  sv_vm_t *vm, ant_t *js, ant_value_t *iter_buf
) {
  GC_ROOT_SAVE(root_mark, js);

  int tag = (int)js_getnum(iter_buf[2]);
  if (tag == SV_ITER_GENERIC) {
    ant_value_t iterator = iter_buf[0];
    GC_ROOT_PIN(js, iterator);
    ant_value_t return_fn = js_getprop_fallback(js, iterator, "return");
    GC_ROOT_PIN(js, return_fn);
    if (is_callable(return_fn))
      sv_vm_call(vm, js, return_fn, iterator, NULL, 0, NULL, false);
  }

  GC_ROOT_RESTORE(js, root_mark);
}

ant_value_t jit_helper_for_of(
  sv_vm_t *vm, ant_t *js,
  ant_value_t iterable, ant_value_t *iter_buf
) {
  GC_ROOT_SAVE(root_mark, js);
  GC_ROOT_PIN(js, iterable);

  if (vtype(iterable) == T_ARR) {
    iter_buf[0] = iterable;
    iter_buf[1] = tov(0);
    iter_buf[2] = tov(SV_ITER_ARRAY);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  if (vtype(iterable) == T_STR) {
    if (str_is_heap_rope(iterable) || str_is_heap_builder(iterable)) {
      iterable = str_materialize(js, iterable);
      if (is_err(iterable)) {
        GC_ROOT_RESTORE(js, root_mark);
        return iterable;
      }
      GC_ROOT_PIN(js, iterable);
    }
    iter_buf[0] = iterable;
    iter_buf[1] = tov(0);
    iter_buf[2] = tov(SV_ITER_STRING);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  ant_value_t iter_fn = js_get_sym(js, iterable, get_iterator_sym());
  GC_ROOT_PIN(js, iter_fn);
  if (!is_callable(iter_fn)) {
    GC_ROOT_RESTORE(js, root_mark);
    return js_mkerr(js, "not iterable");
  }
  ant_value_t iterator = sv_vm_call(vm, js, iter_fn, iterable, NULL, 0, NULL, false);
  if (is_err(iterator)) {
    GC_ROOT_RESTORE(js, root_mark);
    return iterator;
  }
  GC_ROOT_PIN(js, iterator);

  map_iterator_state_t *map_st;
  iter_type_t map_type;
  if (sv_is_map_iter(js, iterator, &map_st, &map_type)) {
    iter_buf[0] = ANT_PTR(map_st);
    iter_buf[1] = tov((double)map_type);
    iter_buf[2] = tov(SV_ITER_MAP);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  set_iterator_state_t *set_st;
  iter_type_t set_type;
  if (sv_is_set_iter(js, iterator, &set_st, &set_type)) {
    iter_buf[0] = ANT_PTR(set_st);
    iter_buf[1] = tov((double)set_type);
    iter_buf[2] = tov(SV_ITER_SET);
    GC_ROOT_RESTORE(js, root_mark);
    return tov(0);
  }

  ant_value_t next_method = js_getprop_fallback(js, iterator, "next");
  GC_ROOT_PIN(js, next_method);
  iter_buf[0] = iterator;
  iter_buf[1] = next_method;
  iter_buf[2] = tov(SV_ITER_GENERIC);
  GC_ROOT_RESTORE(js, root_mark);
  return tov(0);
}

ant_value_t jit_helper_destructure_next(
  sv_vm_t *vm, ant_t *js,
  ant_value_t *iter_buf
) {
  ant_value_t value = js_mkundef();
  bool done = false;
  ant_value_t status = jit_iter_advance_from_buf(vm, js, iter_buf, 0, &value, &done);
  if (is_err(status)) return status;

  iter_buf[3] = done ? js_mkundef() : value;
  return status;
}

ant_value_t jit_helper_seq(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  return mkval(T_BOOL, strict_eq_values(js, l, r));
}

ant_value_t jit_helper_in(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  return do_in(js, l, r);
}

ant_value_t jit_helper_eq(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  return sv_abstract_eq(js, l, r);
}

ant_value_t jit_helper_throw(sv_vm_t *vm, ant_t *js, ant_value_t val) {
  return js_throw(js, val);
}

ant_value_t jit_helper_ne(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  ant_value_t eq = sv_abstract_eq(js, l, r);
  return mkval(T_BOOL, !vdata(eq));
}

ant_value_t jit_helper_sne(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  return mkval(T_BOOL, !strict_eq_values(js, l, r));
}

ant_value_t jit_helper_not(sv_vm_t *vm, ant_t *js, ant_value_t v) {
  return mkval(T_BOOL, !js_truthy(js, v));
}

ant_value_t jit_helper_instanceof(
  sv_vm_t *vm, ant_t *js,
  ant_value_t l, ant_value_t r,
  sv_func_t *func, int32_t bc_off
) {
  (void)vm;
  uint8_t *ip = NULL;
  if (func && bc_off >= 0 && bc_off < func->code_len) ip = func->code + bc_off;
  return sv_instanceof_ic_eval(js, l, r, func, ip);
}

ant_value_t jit_helper_call_is_proto(
  sv_vm_t *vm, ant_t *js,
  ant_value_t call_this, ant_value_t call_func, ant_value_t arg,
  sv_func_t *func, int32_t bc_off
) {
  uint8_t *ip = NULL;
  if (func && bc_off >= 0 && bc_off < func->code_len) ip = func->code + bc_off;
  if (vtype(call_func) == T_CFUNC && js_cfunc_same_entrypoint(call_func, builtin_object_isPrototypeOf)) {
    return sv_isproto_ic_eval(js, call_this, arg, func, ip);
  }
  ant_value_t args[1] = { arg };
  return sv_vm_call(vm, js, call_func, call_this, args, 1, NULL, false);
}

ant_value_t jit_helper_call_array_includes(
  sv_vm_t *vm, ant_t *js,
  ant_value_t call_func, ant_value_t call_this,
  ant_value_t *args, int argc
) {
  if (js_is_array_includes_builtin(call_func))
    return js_array_includes_call(js, call_this, args, argc);
  return sv_vm_call(vm, js, call_func, call_this, args, argc, NULL, false);
}

// TODO: dont bail out
ant_value_t jit_helper_typeof(sv_vm_t *vm, ant_t *js, ant_value_t v) {
  return SV_JIT_BAILOUT;
}

int64_t jit_helper_is_truthy(ant_t *js, ant_value_t v) {
  return (int64_t)js_truthy(js, v);
}

static inline void jit_set_error_site_from_func(ant_t *js, sv_func_t *func, int32_t bc_off) {
  if (!func) return;
  js_set_error_site_from_bc(js, func, (int)bc_off, func->filename);
}

ant_value_t jit_helper_get_field(
  sv_vm_t *vm, ant_t *js, ant_value_t obj, 
  const char *str, uint32_t len, sv_func_t *func, int32_t bc_off
) {
  (void)vm;
  uint8_t *ip = NULL;
  if (func && bc_off >= 0 && bc_off < func->code_len) ip = func->code + bc_off;
  sv_atom_t atom = { .str = str, .len = len };
  ant_value_t out = sv_prop_get_field_ic(js, obj, &atom, func, ip);
  if ((vtype(obj) == T_NULL || vtype(obj) == T_UNDEF) && is_err(out))
    jit_set_error_site_from_func(js, func, bc_off);
  return out;
}

ant_value_t jit_helper_to_propkey(sv_vm_t *vm, ant_t *js, ant_value_t v) {
  if (vtype(v) == T_STR || vtype(v) == T_SYMBOL) return v;
  return coerce_to_str(js, v);
}

static inline sv_upvalue_t *jit_make_undef_upvalue(void) {
  sv_upvalue_t *uv = js_upvalue_alloc();
  uv->closed = js_mkundef();
  uv->location = &uv->closed;
  return uv;
}

ant_value_t jit_helper_closure(
  sv_vm_t *vm, ant_t *js, sv_closure_t *parent_closure,
  ant_value_t this_val, ant_value_t *slots,
  int slot_base, int slot_count, uint32_t const_idx
) {
  sv_func_t *parent_func = parent_closure->func;
  sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(parent_func->constants[const_idx]);

  sv_closure_t *closure = js_closure_alloc(js);
  if (!closure) return mkval(T_ERR, 0);

  closure->func = child;
  closure->bound_this = child->is_arrow ? this_val : js_mkundef();
  closure->bound_args = js_mkundef();
  closure->super_val = js_mkundef();
  closure->call_flags = child->is_arrow ? SV_CALL_IS_ARROW : 0;

  if (child->upvalue_count > 0)
    closure->upvalues = calloc((size_t)child->upvalue_count, sizeof(sv_upvalue_t *));

  for (int i = 0; i < child->upvalue_count; i++) {
    sv_upval_desc_t *desc = &child->upval_descs[i];
    if (!desc->is_local) {
      closure->upvalues[i] = parent_closure->upvalues[desc->index];
      continue;
    }
    
    int idx = (int)desc->index - slot_base;
    if (!slots || idx < 0 || idx >= slot_count) {
      closure->upvalues[i] = jit_make_undef_upvalue();
      continue;
    }
    
    closure->upvalues[i] = sv_capture_upvalue(vm, &slots[idx]);
  }

  ant_value_t func_obj = mkobj(js, 0);
  closure->func_obj = func_obj;
  ant_value_t module_ctx = sv_get_current_closure_module_ctx(js, mkval(T_FUNC, (uintptr_t)parent_closure));
  
  js_mark_constructor(func_obj, !child->is_arrow && !child->is_method && !child->is_generator && !child->is_async);
  js_setprop(js, func_obj, js->length_str, tov((double)child->param_count));
  js_set_descriptor(js, func_obj, "length", 6, JS_DESC_C);
  
  if (is_object_type(module_ctx))
    js_set_slot_wb(js, func_obj, SLOT_MODULE_CTX, module_ctx);

  ant_value_t func_val = mkval(T_FUNC, (uintptr_t)closure);
  if (!child->is_arrow && !child->is_method && (!child->is_async || child->is_generator)) {
    ant_value_t parent_proto = child->is_async
      ? js->sym.async_generator_proto
      : (child->is_generator ? js->sym.generator_proto : js->sym.object_proto);
    sv_setup_function_prototype_with_parent(js, func_obj, func_val, parent_proto);
  }
  
  if (child->is_async && child->is_generator) {
    js_set_slot(func_obj, SLOT_ASYNC, js_true);
    ant_value_t async_generator_proto = js_get_slot(js->global, SLOT_ASYNC_GENERATOR_PROTO);
    if (vtype(async_generator_proto) == T_FUNC) js_set_proto_init(func_obj, async_generator_proto);
  }
  
  else if (child->is_async) {
    js_set_slot(func_obj, SLOT_ASYNC, js_true);
    ant_value_t async_proto = js_get_slot(js->global, SLOT_ASYNC_PROTO);
    if (vtype(async_proto) == T_FUNC) js_set_proto_init(func_obj, async_proto);
  }
  
  else if (child->is_generator) {
    ant_value_t generator_proto = js_get_slot(js->global, SLOT_GENERATOR_PROTO);
    if (vtype(generator_proto) == T_FUNC) js_set_proto_init(func_obj, generator_proto);
  }
  
  else {
    ant_value_t func_proto = js_get_slot(js->global, SLOT_FUNC_PROTO);
    if (vtype(func_proto) == T_FUNC) js_set_proto_init(func_obj, func_proto);
  }

  return func_val;
}

void jit_helper_close_upval(sv_vm_t *vm, uint16_t slot_idx, ant_value_t *slots, int slot_count) {
  if (!slots || slot_count <= 0) return;
  if ((int)slot_idx >= slot_count) return;

  ant_value_t *lo = slots + slot_idx;
  ant_value_t *hi = slots + slot_count;
  sv_upvalue_t **pp = &vm->open_upvalues;
  
  while (*pp) {
    sv_upvalue_t *uv = *pp;
    if (uv->location < lo) break;
    if (uv->location >= lo && uv->location < hi) {
      uv->closed = *uv->location;
      uv->location = &uv->closed;
      *pp = uv->next;
    } 
    else pp = &uv->next;
  }
}

ant_value_t jit_helper_bailout_resume(
  sv_vm_t *vm, sv_closure_t *closure,
  ant_value_t this_val, ant_value_t *args, int argc,
  ant_value_t *vstack, int64_t vstack_sp,
  ant_value_t *locals, int64_t n_locals,
  int64_t bc_offset
) {
  if (!closure || !closure->func) return mkval(T_ERR, 0);
  sv_func_t *fn = closure->func;
  sv_jit_on_bailout(fn);

  vm->jit_resume.active     = true;
  vm->jit_resume.ip_offset  = (int)bc_offset;
  vm->jit_resume.locals     = locals;
  vm->jit_resume.n_locals   = n_locals;
  vm->jit_resume.vstack     = vstack;
  vm->jit_resume.vstack_sp  = vstack_sp;

  return sv_execute_closure_entry(
    vm, closure, closure->func_obj, js_mkundef(),
    this_val, args, argc, NULL
  );
}

void jit_helper_define_field(
  sv_vm_t *vm, ant_t *js, ant_value_t obj,
  ant_value_t val, const char *str, uint32_t len
) {
  if (!sv_try_define_field_fast(js, obj, str, val))
    js_define_own_prop(js, obj, str, len, val);
}


void jit_helper_set_name(
  sv_vm_t *vm, ant_t *js, ant_value_t fn,
  const char *str, uint32_t len
) {
  ant_value_t name = js_mkstr(js, str, len);
  setprop_cstr(js, fn, "name", 4, name);
}

ant_value_t jit_helper_get_length(sv_vm_t *vm, ant_t *js, ant_value_t obj) {
  if (vtype(obj) == T_ARR)
    return tov((double)(uint32_t)js_arr_len(js, obj));
  if (vtype(obj) == T_STR) {
    ant_flat_string_t *flat = ant_str_flat_ptr(obj);
    if (flat) {
      const char *str_data = flat->bytes;
      ant_offset_t byte_len = flat->len;
      return tov((double)(uint32_t)(
        str_is_ascii(str_data) 
          ? byte_len 
          : utf16_strlen(str_data, byte_len)
      ));
    }
    ant_offset_t byte_len = 0;
    ant_offset_t off = vstr(js, obj, &byte_len);
    const char *str_data = (const char *)(uintptr_t)(off);
    return tov((double)(uint32_t)utf16_strlen(str_data, byte_len));
  }
  return js_getprop_fallback(js, obj, "length");
}

ant_value_t jit_helper_put_field(
  sv_vm_t *vm, ant_t *js, ant_value_t obj,
  ant_value_t val, const char *str, uint32_t len
) {
  ant_value_t key = js_mkstr(js, str, len);
  return js_setprop(js, obj, key, val);
}

ant_value_t jit_helper_get_elem(
  sv_vm_t *vm, ant_t *js, ant_value_t obj, 
  ant_value_t key, sv_func_t *func, int32_t bc_off
) {
  uint8_t ot = vtype(obj);
  if (ot == T_NULL || ot == T_UNDEF) {
    jit_set_error_site_from_func(js, func, bc_off);
    return sv_mk_nullish_read_error_by_key(js, obj, key);
  }
  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
    double d = tod(key);
    if (d >= 0 && d == (uint32_t)d)
      return js_arr_get(js, obj, (uint32_t)d);
  }
  ant_value_t str_elem = js_mkundef();
  if (sv_try_string_index_get(js, obj, key, &str_elem))
    return str_elem;
  return sv_getprop_by_key(js, obj, key);
}

ant_value_t jit_helper_put_elem(
  sv_vm_t *vm, ant_t *js,
  ant_value_t obj, ant_value_t key, ant_value_t val
) {
  if (vtype(key) == T_SYMBOL) return js_setprop(js, obj, key, val);
  ant_value_t key_jv = sv_key_to_propstr(js, key);
  return js_setprop(js, obj, key_jv, val);
}

ant_value_t jit_helper_put_global(
  sv_vm_t *vm, ant_t *js, ant_value_t val,
  const char *str, uint32_t len, int is_strict
) {
  if (is_strict && lkp(js, js->global, str, len) == 0)
    return js_mkerr_typed(js, JS_ERR_REFERENCE, "'%.*s' is not defined", (int)len, str);
  ant_value_t key = js_mkstr(js, str, len);
  return js_setprop(js, js->global, key, val);
}

ant_value_t jit_helper_object(sv_vm_t *vm, ant_t *js) {
  ant_value_t obj = mkobj(js, 0);
  ant_value_t proto = js->sym.object_proto;
  if (vtype(proto) == T_OBJ) js_set_proto_init(obj, proto);
  return obj;
}

ant_value_t jit_helper_array(sv_vm_t *vm, ant_t *js, ant_value_t *elements, int count) {
  ant_value_t arr = js_mkarr(js);
  for (int i = 0; i < count; i++)
    js_arr_push(js, arr, elements[i]);
  return arr;
}

ant_value_t jit_helper_catch_value(sv_vm_t *vm, ant_t *js, ant_value_t err) {
  if (vtype(err) == T_ERR && js->thrown_exists &&
      vtype(js->thrown_value) != T_UNDEF) {
    ant_value_t caught = js->thrown_value;
    js->thrown_value = js_mkundef();
    js->thrown_exists = false;
    return caught;
  }
  return err;
}

ant_value_t jit_helper_throw_error(
  sv_vm_t *vm, ant_t *js,
  const char *str, uint32_t len, int err_type
) { return js_mkerr_typed(js, (js_err_type_t)err_type, "%.*s", (int)len, str); }

ant_value_t jit_helper_get_elem2(sv_vm_t *vm, ant_t *js, ant_value_t obj, ant_value_t key) {
  if (vtype(obj) == T_ARR && vtype(key) == T_NUM) {
    double d = tod(key);
    if (d >= 0 && d == (uint32_t)d)
      return js_arr_get(js, obj, (uint32_t)d);
  }
  ant_value_t str_elem = js_mkundef();
  if (sv_try_string_index_get(js, obj, key, &str_elem))
    return str_elem;
  return sv_getprop_by_key(js, obj, key);
}

ant_value_t jit_helper_set_proto(sv_vm_t *vm, ant_t *js, ant_value_t obj, ant_value_t proto) {
  uint8_t pt = vtype(proto);
  if (pt == T_OBJ || pt == T_NULL || pt == T_FUNC || pt == T_ARR) js_set_proto_wb(js, obj, proto);
  return js_mkundef();
}

ant_value_t jit_helper_band(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
  int32_t ai = js_to_int32(tod(l));
  int32_t bi = js_to_int32(tod(r));
  return tov((double)(ai & bi));
}

ant_value_t jit_helper_bor(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (!((vtype(l) == T_NUM || vtype(l) == T_STR) && (vtype(r) == T_NUM || vtype(r) == T_STR))) return SV_JIT_BAILOUT;
  int32_t ai = js_to_int32((vtype(l) == T_NUM) ? tod(l) : js_to_number(js, l));
  int32_t bi = js_to_int32((vtype(r) == T_NUM) ? tod(r) : js_to_number(js, r));
  return tov((double)(ai | bi));
}

ant_value_t jit_helper_bxor(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
  int32_t ai = js_to_int32(tod(l));
  int32_t bi = js_to_int32(tod(r));
  return tov((double)(ai ^ bi));
}

ant_value_t jit_helper_bnot(sv_vm_t *vm, ant_t *js, ant_value_t v) {
  if (vtype(v) != T_NUM) return SV_JIT_BAILOUT;
  return tov((double)(~js_to_int32(tod(v))));
}

ant_value_t jit_helper_shl(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
  int32_t ai = js_to_int32(tod(l));
  uint32_t bi = js_to_uint32(tod(r));
  return tov((double)(ai << (bi & 0x1f)));
}

ant_value_t jit_helper_shr(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
  int32_t ai = js_to_int32(tod(l));
  uint32_t bi = js_to_uint32(tod(r));
  return tov((double)(ai >> (bi & 0x1f)));
}

ant_value_t jit_helper_ushr(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) != T_NUM || vtype(r) != T_NUM) return SV_JIT_BAILOUT;
  uint32_t ai = js_to_uint32(tod(l));
  uint32_t bi = js_to_uint32(tod(r));
  return tov((double)(ai >> (bi & 0x1f)));
}

ant_value_t jit_helper_gt(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM)
    return js_bool(tod(l) > tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_ge(sv_vm_t *vm, ant_t *js, ant_value_t l, ant_value_t r) {
  if (vtype(l) == T_NUM && vtype(r) == T_NUM)
    return js_bool(tod(l) >= tod(r));
  return SV_JIT_BAILOUT;
}

ant_value_t jit_helper_delete(sv_vm_t *vm, ant_t *js, ant_value_t obj, ant_value_t key) {
  ant_value_t key_str = js_mkundef();

  if (vtype(key) == T_SYMBOL) 
    return js_delete_sym_prop(js, obj, key);
  else key_str = coerce_to_str(js, key);

  if (!is_err(key_str) && vtype(key_str) == T_STR) {
    ant_offset_t klen = 0;
    ant_offset_t koff = vstr(js, key_str, &klen);
    const char *kptr = (const char *)(uintptr_t)(koff);
    return js_delete_prop(js, obj, kptr, klen);
  }
  return mkval(T_BOOL, 0);
}

ant_value_t jit_helper_new(
  sv_vm_t *vm, ant_t *js,
  ant_value_t func, ant_value_t new_target,
  ant_value_t *args, int argc
) {
  ant_value_t record_func = func;
  js->new_target = new_target;

  if (vtype(func) == T_OBJ && is_proxy(func))
    return js_proxy_construct(js, func, args, argc, new_target);
  if (!js_is_constructor(func))
    return js_mkerr_typed(js, JS_ERR_TYPE, "not a constructor");

  ant_value_t proto = js_mkundef();
  if (vtype(func) == T_FUNC) {
    ant_value_t proto_source = func;
    ant_value_t func_obj = js_func_obj(func);
    ant_value_t target_func = js_get_slot(func_obj, SLOT_TARGET_FUNC);
    if (vtype(target_func) == T_FUNC) {
      proto_source = target_func;
      record_func = target_func;
    }
    proto = js_getprop_fallback(js, proto_source, "prototype");
  }

  ant_value_t obj = js_mkobj_with_inobj_limit(js, sv_tfb_ctor_inobj_limit(record_func));
  if (is_object_type(proto)) js_set_proto_init(obj, proto);
  ant_value_t ctor_this = obj;
  ant_value_t result = sv_vm_call(vm, js, func, obj, args, argc, &ctor_this, true);

  if (is_err(result)) return result;
  ant_value_t final_obj =
    is_object_type(result) ? result
    : (is_object_type(ctor_this) ? ctor_this : obj);
  sv_tfb_record_ctor_prop_count(record_func, final_obj);
  return final_obj;
}

#endif