+16

examples/jit/closures.js

reviewed

··· 84 84 let r8 = test8(1000); 85 85 let e8 = (999 * 1000) / 2; 86 86 console.log('[test8] hot closure call:', r8, 'ok:', r8 === e8); 87 87 + 88 88 + function test9() { 89 89 + let x = 0; 90 90 + let obj = { 91 91 + m: function () { 92 92 + x = 10; 93 93 + } 94 94 + }; 95 95 + for (let i = 0; i < 1; x++) { 96 96 + obj.m(); 97 97 + i++; 98 98 + } 99 99 + return x; 100 100 + } 101 101 + for (let i = 0; i < 110; i++) test9(); 102 102 + console.log('[test9] captured loop update:', test9(), 'ok:', test9() === 11);

+11

examples/jit/osr.js

reviewed

··· 83 83 let t6_expected = 42 + 99 + N; 84 84 console.log(`[test6] ${t6.name}: ${t6.elapsed}ms result=${t6.result} ok=${t6.result === t6_expected}`); 85 85 86 86 + function postIncrementLoop(n) { 87 87 + let i = 0; 88 88 + while (i < n) i++; 89 89 + return i; 90 90 + } 91 91 + 92 92 + let t6b = bench('post-inc loop local', () => postIncrementLoop(N)); 93 93 + console.log(`[test6b] ${t6b.name}: ${t6b.elapsed}ms result=${t6b.result} ok=${t6b.result === N}`); 94 94 + 86 95 function hotAdd(a, b) { 87 96 return a + b; 88 97 } ··· 114 123 t4.result === t4_expected && 115 124 t5.result === N && 116 125 t6.result === t6_expected && 126 126 + t6b.result === N && 117 127 t7_call.result === t7_osr.result; 118 128 119 129 console.log(''); ··· 124 134 console.log(` loop + JIT callee: ${t4.elapsed}ms`); 125 135 console.log(` while loop: ${t5.elapsed}ms`); 126 136 console.log(` local preservation: ${t6.elapsed}ms`); 137 137 + console.log(` post-inc loop local: ${t6b.elapsed}ms`); 127 138 console.log(` hot fn (call JIT): ${t7_call.elapsed}ms`); 128 139 console.log(` cold fn (OSR JIT): ${t7_osr.elapsed}ms`); 129 140 console.log('');

+48 -1

examples/jit/type_feedback.js

reviewed

··· 136 136 let r13 = concatLoop('start', 5); 137 137 console.log('[string concat loop]', r13, 'ok:', r13 === 'start.....'); 138 138 139 139 + function numericInitThenString() { 140 140 + let x = 0; 141 141 + x = 'safe'; 142 142 + return x; 143 143 + } 144 144 + for (let i = 0; i < 200; i++) numericInitThenString(); 145 145 + let r14 = numericInitThenString(); 146 146 + console.log('[numeric init then string]', r14, 'ok:', r14 === 'safe'); 147 147 + 148 148 + function numericInitBranchString(flag) { 149 149 + let x = 0; 150 150 + if (flag) x = 's'; 151 151 + return x + 1; 152 152 + } 153 153 + for (let i = 0; i < 200; i++) numericInitBranchString(false); 154 154 + let r15 = numericInitBranchString(true); 155 155 + let r16 = numericInitBranchString(false); 156 156 + console.log('[numeric init branch string]', r15, 'ok:', r15 === 's1'); 157 157 + console.log('[numeric init branch number]', r16, 'ok:', r16 === 1); 158 158 + 159 159 + function conditionalLocalAdd(flag) { 160 160 + let x = flag ? 'p' : 2; 161 161 + return x + 1; 162 162 + } 163 163 + for (let i = 0; i < 200; i++) conditionalLocalAdd(false); 164 164 + let r17 = conditionalLocalAdd(true); 165 165 + let r18 = conditionalLocalAdd(false); 166 166 + console.log('[conditional local add bailout]', r17, 'ok:', r17 === 'p1'); 167 167 + console.log('[conditional local add warm]', r18, 'ok:', r18 === 3); 168 168 + 169 169 + function conditionalLocalMul(flag) { 170 170 + let x = flag ? 'p' : 2; 171 171 + return x * 2; 172 172 + } 173 173 + for (let i = 0; i < 200; i++) conditionalLocalMul(false); 174 174 + let r19 = conditionalLocalMul(true); 175 175 + let r20 = conditionalLocalMul(false); 176 176 + console.log('[conditional local mul bailout]', r19, 'ok:', Number.isNaN(r19)); 177 177 + console.log('[conditional local mul warm]', r20, 'ok:', r20 === 4); 178 178 + 139 179 let allOk = 140 180 r1 === 142 && 141 181 r2 === 42 && ··· 158 198 r10 === expected && 159 199 r11 === 7 && 160 200 r12 === 49 && 161 161 - r13 === 'start.....'; 201 201 + r13 === 'start.....' && 202 202 + r14 === 'safe' && 203 203 + r15 === 's1' && 204 204 + r16 === 1 && 205 205 + r17 === 'p1' && 206 206 + r18 === 3 && 207 207 + Number.isNaN(r19) && 208 208 + r20 === 4; 162 209 163 210 console.log(''); 164 211 console.log('all type feedback tests passed:', allOk);

+359 -473

src/silver/swarm.c

reviewed

··· 262 262 vstack_ensure_boxed(vs, i, ctx, fn, d_slot); 263 263 } 264 264 265 265 - static void mir_emit_bailout_check(MIR_context_t ctx, MIR_item_t fn, 266 266 - MIR_reg_t res, 267 267 - MIR_reg_t restore_val, 268 268 - MIR_reg_t r_bailout_off, int bc_off, 269 269 - MIR_reg_t r_bailout_sp, int pre_op_sp, 270 270 - MIR_label_t bailout_tramp, 271 271 - MIR_reg_t r_args_buf, 272 272 - jit_vstack_t *vs, 273 273 - MIR_reg_t *local_regs, int n_locals, 274 274 - MIR_reg_t r_lbuf, 275 275 - MIR_reg_t r_d_slot) { 276 276 - MIR_label_t no_bail = MIR_new_label(ctx); 277 277 - MIR_append_insn(ctx, fn, 278 278 - MIR_new_insn(ctx, MIR_BNE, 279 279 - MIR_new_label_op(ctx, no_bail), 280 280 - MIR_new_reg_op(ctx, res), 281 281 - MIR_new_uint_op(ctx, (uint64_t)SV_JIT_BAILOUT))); 282 282 - if (restore_val) 283 283 - MIR_append_insn(ctx, fn, 284 284 - MIR_new_insn(ctx, MIR_MOV, 285 285 - MIR_new_reg_op(ctx, res), 286 286 - MIR_new_reg_op(ctx, restore_val))); 265 265 + typedef struct { 266 266 + MIR_reg_t val; 267 267 + MIR_reg_t off; 268 268 + MIR_reg_t sp; 269 269 + MIR_label_t tramp; 270 270 + MIR_reg_t args_buf; 271 271 + jit_vstack_t *vstack; 272 272 + MIR_reg_t *local_regs; 273 273 + int n_locals; 274 274 + MIR_reg_t lbuf; 275 275 + MIR_reg_t d_slot; 276 276 + } jit_bailout_emit_t; 277 277 + 278 278 + static bool jit_bailout_slot_was_num(jit_vstack_t *vs, int idx, 279 279 + int left_idx, bool left_is_num, 280 280 + int right_idx, bool right_is_num) { 281 281 + if (idx == left_idx) return left_is_num; 282 282 + if (idx == right_idx) return right_is_num; 283 283 + return vs->slot_type && vs->slot_type[idx] == SLOT_NUM; 284 284 + } 285 285 + 286 286 + static void mir_emit_bailout_jump_typed(MIR_context_t ctx, MIR_item_t fn, 287 287 + MIR_reg_t r_bailout_off, int bc_off, 288 288 + MIR_reg_t r_bailout_sp, int pre_op_sp, 289 289 + MIR_label_t bailout_tramp, 290 290 + MIR_reg_t r_args_buf, 291 291 + jit_vstack_t *vs, 292 292 + MIR_reg_t *local_regs, int n_locals, 293 293 + MIR_reg_t r_lbuf, 294 294 + MIR_reg_t r_d_slot, 295 295 + int left_idx, bool left_is_num, 296 296 + int right_idx, bool right_is_num) { 287 297 for (int i = 0; i < pre_op_sp; i++) { 288 288 - if (vs->slot_type && vs->slot_type[i] == SLOT_NUM) 298 298 + if (jit_bailout_slot_was_num(vs, i, left_idx, left_is_num, 299 299 + right_idx, right_is_num)) 289 300 mir_d_to_i64(ctx, fn, vs->regs[i], vs->d_regs[i], r_d_slot); 290 301 MIR_append_insn(ctx, fn, 291 302 MIR_new_insn(ctx, MIR_MOV, ··· 310 321 MIR_append_insn(ctx, fn, 311 322 MIR_new_insn(ctx, MIR_JMP, 312 323 MIR_new_label_op(ctx, bailout_tramp))); 324 324 + } 325 325 + 326 326 + static void mir_emit_bailout_check_typed(MIR_context_t ctx, MIR_item_t fn, 327 327 + MIR_reg_t res, 328 328 + MIR_reg_t restore_val, 329 329 + MIR_reg_t r_bailout_off, int bc_off, 330 330 + MIR_reg_t r_bailout_sp, int pre_op_sp, 331 331 + MIR_label_t bailout_tramp, 332 332 + MIR_reg_t r_args_buf, 333 333 + jit_vstack_t *vs, 334 334 + MIR_reg_t *local_regs, int n_locals, 335 335 + MIR_reg_t r_lbuf, 336 336 + MIR_reg_t r_d_slot, 337 337 + int left_idx, bool left_is_num, 338 338 + int right_idx, bool right_is_num) { 339 339 + MIR_label_t no_bail = MIR_new_label(ctx); 340 340 + MIR_append_insn(ctx, fn, 341 341 + MIR_new_insn(ctx, MIR_BNE, 342 342 + MIR_new_label_op(ctx, no_bail), 343 343 + MIR_new_reg_op(ctx, res), 344 344 + MIR_new_uint_op(ctx, (uint64_t)SV_JIT_BAILOUT))); 345 345 + if (restore_val) 346 346 + MIR_append_insn(ctx, fn, 347 347 + MIR_new_insn(ctx, MIR_MOV, 348 348 + MIR_new_reg_op(ctx, res), 349 349 + MIR_new_reg_op(ctx, restore_val))); 350 350 + mir_emit_bailout_jump_typed(ctx, fn, 351 351 + r_bailout_off, bc_off, 352 352 + r_bailout_sp, pre_op_sp, bailout_tramp, 353 353 + r_args_buf, vs, local_regs, n_locals, r_lbuf, r_d_slot, 354 354 + left_idx, left_is_num, right_idx, right_is_num); 313 355 MIR_append_insn(ctx, fn, no_bail); 314 356 } 315 357 358 358 + static void mir_emit_bailout_check(MIR_context_t ctx, MIR_item_t fn, 359 359 + MIR_reg_t res, 360 360 + MIR_reg_t restore_val, 361 361 + MIR_reg_t r_bailout_off, int bc_off, 362 362 + MIR_reg_t r_bailout_sp, int pre_op_sp, 363 363 + MIR_label_t bailout_tramp, 364 364 + MIR_reg_t r_args_buf, 365 365 + jit_vstack_t *vs, 366 366 + MIR_reg_t *local_regs, int n_locals, 367 367 + MIR_reg_t r_lbuf, 368 368 + MIR_reg_t r_d_slot) { 369 369 + mir_emit_bailout_check_typed(ctx, fn, res, restore_val, 370 370 + r_bailout_off, bc_off, 371 371 + r_bailout_sp, pre_op_sp, bailout_tramp, 372 372 + r_args_buf, vs, local_regs, n_locals, r_lbuf, r_d_slot, 373 373 + -1, false, -1, false); 374 374 + } 375 375 + 316 376 317 377 static void mir_load_imm(MIR_context_t ctx, MIR_item_t fn, 318 378 MIR_reg_t dst, uint64_t imm) { ··· 490 550 MIR_new_label_op(ctx, slow), 491 551 MIR_new_reg_op(ctx, v), 492 552 MIR_new_uint_op(ctx, NANBOX_PREFIX))); 553 553 + } 554 554 + 555 555 + static void mir_emit_numeric_local_store_mirror( 556 556 + MIR_context_t ctx, MIR_item_t fn, 557 557 + MIR_reg_t local_d, 558 558 + MIR_reg_t src, 559 559 + MIR_reg_t src_d, 560 560 + bool src_is_num, 561 561 + MIR_reg_t r_bool, 562 562 + int resume_bc_off, 563 563 + int post_op_sp, 564 564 + jit_bailout_emit_t *bail 565 565 + ) { 566 566 + if (src_is_num) { 567 567 + MIR_append_insn(ctx, fn, 568 568 + MIR_new_insn(ctx, MIR_DMOV, 569 569 + MIR_new_reg_op(ctx, local_d), 570 570 + MIR_new_reg_op(ctx, src_d))); 571 571 + return; 572 572 + } 573 573 + 574 574 + MIR_label_t slow = MIR_new_label(ctx); 575 575 + MIR_label_t done = MIR_new_label(ctx); 576 576 + mir_emit_is_num_guard(ctx, fn, r_bool, src, slow); 577 577 + mir_i64_to_d(ctx, fn, local_d, src, bail->d_slot); 578 578 + MIR_append_insn(ctx, fn, 579 579 + MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, done))); 580 580 + 581 581 + MIR_append_insn(ctx, fn, slow); 582 582 + MIR_append_insn(ctx, fn, 583 583 + MIR_new_insn(ctx, MIR_MOV, 584 584 + MIR_new_reg_op(ctx, bail->val), 585 585 + MIR_new_uint_op(ctx, (uint64_t)SV_JIT_BAILOUT))); 586 586 + mir_emit_bailout_check(ctx, fn, bail->val, 587 587 + 0, bail->off, resume_bc_off, 588 588 + bail->sp, post_op_sp, bail->tramp, 589 589 + bail->args_buf, bail->vstack, bail->local_regs, bail->n_locals, 590 590 + bail->lbuf, bail->d_slot); 591 591 + MIR_append_insn(ctx, fn, done); 493 592 } 494 593 495 594 #define NANBOX_TFUNC_TAG ((NANBOX_PREFIX >> NANBOX_TYPE_SHIFT) | (uint64_t)T_FUNC) ··· 1119 1218 return true; 1120 1219 } 1121 1220 1221 1221 + static bool jit_starts_numeric_const(sv_func_t *func, uint8_t *ip, uint8_t *end, int *out_size) { 1222 1222 + if (!func || !ip || ip >= end) return false; 1223 1223 + sv_op_t op = (sv_op_t)*ip; 1224 1224 + int sz = sv_op_size[op]; 1225 1225 + if (sz == 0 || ip + sz > end) return false; 1226 1226 + if (out_size) *out_size = sz; 1227 1227 + 1228 1228 + switch (op) { 1229 1229 + case OP_CONST_I8: 1230 1230 + return true; 1231 1231 + case OP_CONST: { 1232 1232 + uint32_t idx = sv_get_u32(ip + 1); 1233 1233 + return idx < (uint32_t)func->const_count && 1234 1234 + vtype(func->constants[idx]) == T_NUM; 1235 1235 + } 1236 1236 + case OP_CONST8: { 1237 1237 + uint8_t idx = sv_get_u8(ip + 1); 1238 1238 + return (uint32_t)idx < (uint32_t)func->const_count && 1239 1239 + vtype(func->constants[idx]) == T_NUM; 1240 1240 + } 1241 1241 + default: 1242 1242 + return false; 1243 1243 + } 1244 1244 + } 1245 1245 + 1246 1246 + static bool jit_has_immediate_numeric_local_init(sv_func_t *func, uint8_t *ip, uint8_t *end, uint16_t local_idx) { 1247 1247 + int const_size = 0; 1248 1248 + if (!jit_starts_numeric_const(func, ip, end, &const_size)) return false; 1249 1249 + uint8_t *put_ip = ip + const_size; 1250 1250 + if (put_ip >= end) return false; 1251 1251 + 1252 1252 + sv_op_t put_op = (sv_op_t)*put_ip; 1253 1253 + int put_size = sv_op_size[put_op]; 1254 1254 + if (put_size == 0 || put_ip + put_size > end) return false; 1255 1255 + 1256 1256 + if (put_op == OP_PUT_LOCAL || put_op == OP_SET_LOCAL) 1257 1257 + return sv_get_u16(put_ip + 1) == local_idx; 1258 1258 + if (put_op == OP_PUT_LOCAL8 || put_op == OP_SET_LOCAL8) 1259 1259 + return local_idx <= UINT8_MAX && sv_get_u8(put_ip + 1) == (uint8_t)local_idx; 1260 1260 + return false; 1261 1261 + } 1262 1262 + 1122 1263 static bool jit_emit_inline_body( 1123 1264 MIR_context_t ctx, MIR_item_t jit_func, 1124 1265 sv_func_t *callee, ··· 1879 2020 } 1880 2021 1881 2022 2023 2023 + static bool jit_local_has_numeric_hint(sv_func_t *func, int idx) { 2024 2024 + if (!func || idx < 0) return false; 2025 2025 + if (idx >= func->max_locals) return false; 2026 2026 + if (func->local_types && idx < func->local_type_count && 2027 2027 + func->local_types[idx].type == SV_TI_NUM) 2028 2028 + return true; 2029 2029 + if (func->local_type_feedback) { 2030 2030 + uint8_t ltf = func->local_type_feedback[idx]; 2031 2031 + if (ltf && !(ltf & ~SV_TFB_NUM)) return true; 2032 2032 + } 2033 2033 + return false; 2034 2034 + } 2035 2035 + 1882 2036 typedef struct { 1883 2037 bool needs_bailout; 1884 2038 bool needs_inc_local; ··· 1934 2088 case OP_SET_ARG: 1935 2089 f.needs_bailout = true; 1936 2090 break; 2091 2091 + case OP_PUT_LOCAL: 2092 2092 + case OP_SET_LOCAL: { 2093 2093 + uint16_t idx = sv_get_u16(ip + 1); 2094 2094 + if (jit_local_has_numeric_hint(func, idx)) 2095 2095 + f.needs_bailout = true; 2096 2096 + break; 2097 2097 + } 2098 2098 + case OP_PUT_LOCAL8: 2099 2099 + case OP_SET_LOCAL8: { 2100 2100 + uint8_t idx = sv_get_u8(ip + 1); 2101 2101 + if (jit_local_has_numeric_hint(func, idx)) 2102 2102 + f.needs_bailout = true; 2103 2103 + break; 2104 2104 + } 1937 2105 case OP_GET_FIELD: case OP_GET_FIELD2: case OP_PUT_FIELD: 1938 2106 case OP_INSTANCEOF: case OP_CALL_IS_PROTO: 1939 2107 f.needs_ic_epoch = true; ··· 2738 2906 mir_load_imm(ctx, jit_func, r_lbuf, 0); 2739 2907 } 2740 2908 2909 2909 + jit_bailout_emit_t bailout_ctx = { 2910 2910 + .val = r_bailout_val, 2911 2911 + .off = r_bailout_off, 2912 2912 + .sp = r_bailout_sp, 2913 2913 + .tramp = bailout_tramp, 2914 2914 + .args_buf = r_args_buf, 2915 2915 + .vstack = &vs, 2916 2916 + .local_regs = local_regs, 2917 2917 + .n_locals = n_locals, 2918 2918 + .lbuf = r_lbuf, 2919 2919 + .d_slot = r_d_slot, 2920 2920 + }; 2921 2921 + 2741 2922 if (feat.needs_tco_args && param_count > 0) { 2742 2923 MIR_append_insn(ctx, jit_func, 2743 2924 MIR_new_insn(ctx, MIR_ALLOCA, ··· 2784 2965 MIR_new_mem_op(ctx, MIR_JSVAL, 2785 2966 (MIR_disp_t)(i * (int)sizeof(ant_value_t)), 2786 2967 r_osr_locals, 0, 1))); 2968 2968 + 2969 2969 + if (known_type_locals && local_d_regs) { 2970 2970 + for (int i = 0; i < n_locals; i++) 2971 2971 + if (known_type_locals[i] == SV_TI_NUM) 2972 2972 + mir_i64_to_d(ctx, jit_func, local_d_regs[i], 2973 2973 + local_regs[i], r_d_slot); 2974 2974 + } 2787 2975 2788 2976 if (has_captures) { 2789 2977 MIR_append_insn(ctx, jit_func, ··· 2868 3056 memset(vs.has_const, 0, (size_t)vs.max * sizeof(bool)); 2869 3057 if (known_type_locals && local_d_regs) { 2870 3058 for (int li = 0; li < n_locals; li++) 2871 2871 - if (known_type_locals[li] == SV_TI_NUM) 3059 3059 + if (known_type_locals[li] == SV_TI_NUM 3060 3060 + && has_captures && captured_locals && captured_locals[li]) 2872 3061 mir_i64_to_d(ctx, jit_func, local_d_regs[li], 2873 3062 local_regs[li], r_d_slot); 2874 3063 } ··· 3178 3367 MIR_new_reg_op(ctx, local_regs[idx]), 3179 3368 MIR_new_reg_op(ctx, src))); 3180 3369 if (local_d_regs && known_type_locals && known_type_locals[idx] == SV_TI_NUM) { 3181 3181 - if (src_is_num) 3182 3182 - MIR_append_insn(ctx, jit_func, 3183 3183 - MIR_new_insn(ctx, MIR_DMOV, 3184 3184 - MIR_new_reg_op(ctx, local_d_regs[idx]), 3185 3185 - MIR_new_reg_op(ctx, src_d))); 3186 3186 - else 3187 3187 - mir_i64_to_d(ctx, jit_func, local_d_regs[idx], local_regs[idx], r_d_slot); 3370 3370 + mir_emit_numeric_local_store_mirror(ctx, jit_func, 3371 3371 + local_d_regs[idx], local_regs[idx], src_d, src_is_num, 3372 3372 + r_bool, bc_off + sz, vs.sp, &bailout_ctx); 3188 3373 } 3189 3374 if (has_captures && captured_locals && captured_locals[idx]) 3190 3375 MIR_append_insn(ctx, jit_func, ··· 3208 3393 MIR_new_reg_op(ctx, local_regs[idx]), 3209 3394 MIR_new_reg_op(ctx, src))); 3210 3395 if (local_d_regs && known_type_locals && known_type_locals[idx] == SV_TI_NUM) { 3211 3211 - if (src_is_num) 3212 3212 - MIR_append_insn(ctx, jit_func, 3213 3213 - MIR_new_insn(ctx, MIR_DMOV, 3214 3214 - MIR_new_reg_op(ctx, local_d_regs[idx]), 3215 3215 - MIR_new_reg_op(ctx, src_d))); 3216 3216 - else 3217 3217 - mir_i64_to_d(ctx, jit_func, local_d_regs[idx], local_regs[idx], r_d_slot); 3396 3396 + mir_emit_numeric_local_store_mirror(ctx, jit_func, 3397 3397 + local_d_regs[idx], local_regs[idx], src_d, src_is_num, 3398 3398 + r_bool, bc_off + sz, vs.sp, &bailout_ctx); 3218 3399 } 3219 3400 if (has_captures && captured_locals && captured_locals[idx]) 3220 3401 MIR_append_insn(ctx, jit_func, ··· 3238 3419 MIR_new_reg_op(ctx, local_regs[idx]), 3239 3420 MIR_new_reg_op(ctx, src))); 3240 3421 if (local_d_regs && known_type_locals && known_type_locals[idx] == SV_TI_NUM) { 3241 3241 - if (src_is_num) 3242 3242 - MIR_append_insn(ctx, jit_func, 3243 3243 - MIR_new_insn(ctx, MIR_DMOV, 3244 3244 - MIR_new_reg_op(ctx, local_d_regs[idx]), 3245 3245 - MIR_new_reg_op(ctx, src_d))); 3246 3246 - else 3247 3247 - mir_i64_to_d(ctx, jit_func, local_d_regs[idx], local_regs[idx], r_d_slot); 3422 3422 + mir_emit_numeric_local_store_mirror(ctx, jit_func, 3423 3423 + local_d_regs[idx], local_regs[idx], src_d, src_is_num, 3424 3424 + r_bool, bc_off + sz, vs.sp, &bailout_ctx); 3248 3425 } 3249 3426 if (has_captures && captured_locals && captured_locals[idx]) 3250 3427 MIR_append_insn(ctx, jit_func, ··· 3267 3444 MIR_new_reg_op(ctx, local_regs[idx]), 3268 3445 MIR_new_reg_op(ctx, src))); 3269 3446 if (local_d_regs && known_type_locals && known_type_locals[idx] == SV_TI_NUM) { 3270 3270 - if (src_is_num) 3271 3271 - MIR_append_insn(ctx, jit_func, 3272 3272 - MIR_new_insn(ctx, MIR_DMOV, 3273 3273 - MIR_new_reg_op(ctx, local_d_regs[idx]), 3274 3274 - MIR_new_reg_op(ctx, src_d))); 3275 3275 - else 3276 3276 - mir_i64_to_d(ctx, jit_func, local_d_regs[idx], local_regs[idx], r_d_slot); 3447 3447 + mir_emit_numeric_local_store_mirror(ctx, jit_func, 3448 3448 + local_d_regs[idx], local_regs[idx], src_d, src_is_num, 3449 3449 + r_bool, bc_off + sz, vs.sp, &bailout_ctx); 3277 3450 } 3278 3451 if (has_captures && captured_locals && captured_locals[idx]) 3279 3452 MIR_append_insn(ctx, jit_func, ··· 3287 3460 case OP_SET_LOCAL_UNDEF: { 3288 3461 uint16_t idx = sv_get_u16(ip + 1); 3289 3462 if (idx >= (uint16_t)n_locals) { ok = false; break; } 3290 3290 - if (known_type_locals) known_type_locals[idx] = SV_TI_UNKNOWN; 3463 3463 + if (known_type_locals) { 3464 3464 + bool was_num = known_type_locals[idx] == SV_TI_NUM; 3465 3465 + bool immediate_num_init = 3466 3466 + was_num && 3467 3467 + (!captured_locals || !captured_locals[idx]) && 3468 3468 + jit_has_immediate_numeric_local_init(func, ip + sz, end, idx); 3469 3469 + known_type_locals[idx] = immediate_num_init ? SV_TI_NUM : SV_TI_UNKNOWN; 3470 3470 + } 3291 3471 break; 3292 3472 } 3293 3473 ··· 3402 3582 MIR_reg_t rl = vstack_pop(&vs); 3403 3583 MIR_reg_t rd = vstack_push(&vs); 3404 3584 3405 3405 - if (fb_never_num) { 3406 3406 - int pre_op_sp = vs.sp + 1; 3407 3407 - for (int i = 0; i < pre_op_sp; i++) { 3408 3408 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3409 3409 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3410 3410 - MIR_append_insn(ctx, jit_func, 3411 3411 - MIR_new_insn(ctx, MIR_MOV, 3412 3412 - MIR_new_mem_op(ctx, MIR_T_I64, 3413 3413 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3414 3414 - MIR_new_reg_op(ctx, vs.regs[i]))); 3415 3415 - } 3416 3416 - for (int i = 0; i < n_locals; i++) 3417 3417 - MIR_append_insn(ctx, jit_func, 3418 3418 - MIR_new_insn(ctx, MIR_MOV, 3419 3419 - MIR_new_mem_op(ctx, MIR_T_I64, 3420 3420 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3421 3421 - MIR_new_reg_op(ctx, local_regs[i]))); 3422 3422 - MIR_append_insn(ctx, jit_func, 3423 3423 - MIR_new_insn(ctx, MIR_MOV, 3424 3424 - MIR_new_reg_op(ctx, r_bailout_off), 3425 3425 - MIR_new_int_op(ctx, bc_off))); 3426 3426 - MIR_append_insn(ctx, jit_func, 3427 3427 - MIR_new_insn(ctx, MIR_MOV, 3428 3428 - MIR_new_reg_op(ctx, r_bailout_sp), 3429 3429 - MIR_new_int_op(ctx, pre_op_sp))); 3430 3430 - MIR_append_insn(ctx, jit_func, 3431 3431 - MIR_new_insn(ctx, MIR_JMP, 3432 3432 - MIR_new_label_op(ctx, bailout_tramp))); 3585 3585 + if (fb_never_num) { 3586 3586 + int pre_op_sp = vs.sp + 1; 3587 3587 + mir_emit_bailout_jump_typed(ctx, jit_func, 3588 3588 + r_bailout_off, bc_off, 3589 3589 + r_bailout_sp, pre_op_sp, bailout_tramp, 3590 3590 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3591 3591 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3433 3592 } else if (fb_num_only && l_is_num && r_is_num) { 3434 3593 MIR_reg_t fd_r = vs.d_regs[vs.sp]; 3435 3594 MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1]; ··· 3457 3616 MIR_label_t skip_bail = MIR_new_label(ctx); 3458 3617 MIR_append_insn(ctx, jit_func, 3459 3618 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3460 3460 - MIR_append_insn(ctx, jit_func, bail_direct); 3461 3461 - int pre_op_sp = vs.sp + 1; 3462 3462 - for (int i = 0; i < pre_op_sp; i++) { 3463 3463 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3464 3464 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3465 3465 - MIR_append_insn(ctx, jit_func, 3466 3466 - MIR_new_insn(ctx, MIR_MOV, 3467 3467 - MIR_new_mem_op(ctx, MIR_T_I64, 3468 3468 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3469 3469 - MIR_new_reg_op(ctx, vs.regs[i]))); 3470 3470 - } 3471 3471 - for (int i = 0; i < n_locals; i++) 3472 3472 - MIR_append_insn(ctx, jit_func, 3473 3473 - MIR_new_insn(ctx, MIR_MOV, 3474 3474 - MIR_new_mem_op(ctx, MIR_T_I64, 3475 3475 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3476 3476 - MIR_new_reg_op(ctx, local_regs[i]))); 3477 3477 - MIR_append_insn(ctx, jit_func, 3478 3478 - MIR_new_insn(ctx, MIR_MOV, 3479 3479 - MIR_new_reg_op(ctx, r_bailout_off), 3480 3480 - MIR_new_int_op(ctx, bc_off))); 3481 3481 - MIR_append_insn(ctx, jit_func, 3482 3482 - MIR_new_insn(ctx, MIR_MOV, 3483 3483 - MIR_new_reg_op(ctx, r_bailout_sp), 3484 3484 - MIR_new_int_op(ctx, pre_op_sp))); 3485 3485 - MIR_append_insn(ctx, jit_func, 3486 3486 - MIR_new_insn(ctx, MIR_JMP, 3487 3487 - MIR_new_label_op(ctx, bailout_tramp))); 3619 3619 + MIR_append_insn(ctx, jit_func, bail_direct); 3620 3620 + int pre_op_sp = vs.sp + 1; 3621 3621 + mir_emit_bailout_jump_typed(ctx, jit_func, 3622 3622 + r_bailout_off, bc_off, 3623 3623 + r_bailout_sp, pre_op_sp, bailout_tramp, 3624 3624 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3625 3625 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3488 3626 MIR_append_insn(ctx, jit_func, skip_bail); 3489 3627 } else if (fb_num_only) { 3490 3628 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 3509 3647 MIR_label_t skip_bail = MIR_new_label(ctx); 3510 3648 MIR_append_insn(ctx, jit_func, 3511 3649 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3512 3512 - MIR_append_insn(ctx, jit_func, bail_direct); 3513 3513 - int pre_op_sp = vs.sp + 1; 3514 3514 - for (int i = 0; i < pre_op_sp; i++) { 3515 3515 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3516 3516 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3517 3517 - MIR_append_insn(ctx, jit_func, 3518 3518 - MIR_new_insn(ctx, MIR_MOV, 3519 3519 - MIR_new_mem_op(ctx, MIR_T_I64, 3520 3520 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3521 3521 - MIR_new_reg_op(ctx, vs.regs[i]))); 3522 3522 - } 3523 3523 - for (int i = 0; i < n_locals; i++) 3524 3524 - MIR_append_insn(ctx, jit_func, 3525 3525 - MIR_new_insn(ctx, MIR_MOV, 3526 3526 - MIR_new_mem_op(ctx, MIR_T_I64, 3527 3527 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3528 3528 - MIR_new_reg_op(ctx, local_regs[i]))); 3529 3529 - MIR_append_insn(ctx, jit_func, 3530 3530 - MIR_new_insn(ctx, MIR_MOV, 3531 3531 - MIR_new_reg_op(ctx, r_bailout_off), 3532 3532 - MIR_new_int_op(ctx, bc_off))); 3533 3533 - MIR_append_insn(ctx, jit_func, 3534 3534 - MIR_new_insn(ctx, MIR_MOV, 3535 3535 - MIR_new_reg_op(ctx, r_bailout_sp), 3536 3536 - MIR_new_int_op(ctx, pre_op_sp))); 3537 3537 - MIR_append_insn(ctx, jit_func, 3538 3538 - MIR_new_insn(ctx, MIR_JMP, 3539 3539 - MIR_new_label_op(ctx, bailout_tramp))); 3650 3650 + MIR_append_insn(ctx, jit_func, bail_direct); 3651 3651 + int pre_op_sp = vs.sp + 1; 3652 3652 + mir_emit_bailout_jump_typed(ctx, jit_func, 3653 3653 + r_bailout_off, bc_off, 3654 3654 + r_bailout_sp, pre_op_sp, bailout_tramp, 3655 3655 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3656 3656 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3540 3657 MIR_append_insn(ctx, jit_func, skip_bail); 3541 3658 } else { 3542 3659 MIR_label_t slow = MIR_new_label(ctx); ··· 3569 3686 mir_call_helper2(ctx, jit_func, rd, 3570 3687 helper2_proto, imp_add, 3571 3688 r_vm, r_js, rl, rr); 3572 3572 - mir_emit_bailout_check(ctx, jit_func, rd, 3689 3689 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3573 3690 r_bailout_val, r_bailout_off, bc_off, 3574 3691 r_bailout_sp, vs.sp + 1, bailout_tramp, 3575 3575 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3692 3692 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3693 3693 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3576 3694 MIR_append_insn(ctx, jit_func, done); 3577 3695 } 3578 3696 break; ··· 3600 3718 mir_call_helper2(ctx, jit_func, rd, 3601 3719 helper2_proto, imp_sub, 3602 3720 r_vm, r_js, rl, rr); 3603 3603 - mir_emit_bailout_check(ctx, jit_func, rd, 3721 3721 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3604 3722 r_bailout_val, r_bailout_off, bc_off, 3605 3723 r_bailout_sp, vs.sp + 1, bailout_tramp, 3606 3606 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3724 3724 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3725 3725 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3607 3726 } else if (fb_num_only && l_is_num && r_is_num) { 3608 3727 MIR_reg_t fd_r = vs.d_regs[vs.sp]; 3609 3728 MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1]; ··· 3633 3752 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3634 3753 MIR_append_insn(ctx, jit_func, bail_direct); 3635 3754 int pre_op_sp = vs.sp + 1; 3636 3636 - for (int i = 0; i < pre_op_sp; i++) { 3637 3637 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3638 3638 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3639 3639 - MIR_append_insn(ctx, jit_func, 3640 3640 - MIR_new_insn(ctx, MIR_MOV, 3641 3641 - MIR_new_mem_op(ctx, MIR_T_I64, 3642 3642 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3643 3643 - MIR_new_reg_op(ctx, vs.regs[i]))); 3644 3644 - } 3645 3645 - for (int i = 0; i < n_locals; i++) 3646 3646 - MIR_append_insn(ctx, jit_func, 3647 3647 - MIR_new_insn(ctx, MIR_MOV, 3648 3648 - MIR_new_mem_op(ctx, MIR_T_I64, 3649 3649 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3650 3650 - MIR_new_reg_op(ctx, local_regs[i]))); 3651 3651 - MIR_append_insn(ctx, jit_func, 3652 3652 - MIR_new_insn(ctx, MIR_MOV, 3653 3653 - MIR_new_reg_op(ctx, r_bailout_off), 3654 3654 - MIR_new_int_op(ctx, bc_off))); 3655 3655 - MIR_append_insn(ctx, jit_func, 3656 3656 - MIR_new_insn(ctx, MIR_MOV, 3657 3657 - MIR_new_reg_op(ctx, r_bailout_sp), 3658 3658 - MIR_new_int_op(ctx, pre_op_sp))); 3659 3659 - MIR_append_insn(ctx, jit_func, 3660 3660 - MIR_new_insn(ctx, MIR_JMP, 3661 3661 - MIR_new_label_op(ctx, bailout_tramp))); 3755 3755 + mir_emit_bailout_jump_typed(ctx, jit_func, 3756 3756 + r_bailout_off, bc_off, 3757 3757 + r_bailout_sp, pre_op_sp, bailout_tramp, 3758 3758 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3759 3759 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3662 3760 MIR_append_insn(ctx, jit_func, skip_bail); 3663 3761 } else if (fb_num_only) { 3664 3762 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 3685 3783 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3686 3784 MIR_append_insn(ctx, jit_func, bail_direct); 3687 3785 int pre_op_sp = vs.sp + 1; 3688 3688 - for (int i = 0; i < pre_op_sp; i++) { 3689 3689 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3690 3690 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3691 3691 - MIR_append_insn(ctx, jit_func, 3692 3692 - MIR_new_insn(ctx, MIR_MOV, 3693 3693 - MIR_new_mem_op(ctx, MIR_T_I64, 3694 3694 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3695 3695 - MIR_new_reg_op(ctx, vs.regs[i]))); 3696 3696 - } 3697 3697 - for (int i = 0; i < n_locals; i++) 3698 3698 - MIR_append_insn(ctx, jit_func, 3699 3699 - MIR_new_insn(ctx, MIR_MOV, 3700 3700 - MIR_new_mem_op(ctx, MIR_T_I64, 3701 3701 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3702 3702 - MIR_new_reg_op(ctx, local_regs[i]))); 3703 3703 - MIR_append_insn(ctx, jit_func, 3704 3704 - MIR_new_insn(ctx, MIR_MOV, 3705 3705 - MIR_new_reg_op(ctx, r_bailout_off), 3706 3706 - MIR_new_int_op(ctx, bc_off))); 3707 3707 - MIR_append_insn(ctx, jit_func, 3708 3708 - MIR_new_insn(ctx, MIR_MOV, 3709 3709 - MIR_new_reg_op(ctx, r_bailout_sp), 3710 3710 - MIR_new_int_op(ctx, pre_op_sp))); 3711 3711 - MIR_append_insn(ctx, jit_func, 3712 3712 - MIR_new_insn(ctx, MIR_JMP, 3713 3713 - MIR_new_label_op(ctx, bailout_tramp))); 3786 3786 + mir_emit_bailout_jump_typed(ctx, jit_func, 3787 3787 + r_bailout_off, bc_off, 3788 3788 + r_bailout_sp, pre_op_sp, bailout_tramp, 3789 3789 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3790 3790 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3714 3791 MIR_append_insn(ctx, jit_func, skip_bail); 3715 3792 } else { 3716 3793 MIR_label_t slow = MIR_new_label(ctx); ··· 3742 3819 MIR_new_reg_op(ctx, rl))); 3743 3820 mir_call_helper2(ctx, jit_func, rd, 3744 3821 helper2_proto, imp_sub, r_vm, r_js, rl, rr); 3745 3745 - mir_emit_bailout_check(ctx, jit_func, rd, 3822 3822 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3746 3823 r_bailout_val, r_bailout_off, bc_off, 3747 3824 r_bailout_sp, vs.sp + 1, bailout_tramp, 3748 3748 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3825 3825 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3826 3826 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3749 3827 MIR_append_insn(ctx, jit_func, done); 3750 3828 } 3751 3829 break; ··· 3773 3851 mir_call_helper2(ctx, jit_func, rd, 3774 3852 helper2_proto, imp_mul, 3775 3853 r_vm, r_js, rl, rr); 3776 3776 - mir_emit_bailout_check(ctx, jit_func, rd, 3854 3854 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3777 3855 r_bailout_val, r_bailout_off, bc_off, 3778 3856 r_bailout_sp, vs.sp + 1, bailout_tramp, 3779 3779 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3857 3857 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3858 3858 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3780 3859 } else if (fb_num_only && l_is_num && r_is_num) { 3781 3860 MIR_reg_t fd_r = vs.d_regs[vs.sp]; 3782 3861 MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1]; ··· 3806 3885 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3807 3886 MIR_append_insn(ctx, jit_func, bail_direct); 3808 3887 int pre_op_sp = vs.sp + 1; 3809 3809 - for (int i = 0; i < pre_op_sp; i++) { 3810 3810 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3811 3811 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3812 3812 - MIR_append_insn(ctx, jit_func, 3813 3813 - MIR_new_insn(ctx, MIR_MOV, 3814 3814 - MIR_new_mem_op(ctx, MIR_T_I64, 3815 3815 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3816 3816 - MIR_new_reg_op(ctx, vs.regs[i]))); 3817 3817 - } 3818 3818 - for (int i = 0; i < n_locals; i++) 3819 3819 - MIR_append_insn(ctx, jit_func, 3820 3820 - MIR_new_insn(ctx, MIR_MOV, 3821 3821 - MIR_new_mem_op(ctx, MIR_T_I64, 3822 3822 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3823 3823 - MIR_new_reg_op(ctx, local_regs[i]))); 3824 3824 - MIR_append_insn(ctx, jit_func, 3825 3825 - MIR_new_insn(ctx, MIR_MOV, 3826 3826 - MIR_new_reg_op(ctx, r_bailout_off), 3827 3827 - MIR_new_int_op(ctx, bc_off))); 3828 3828 - MIR_append_insn(ctx, jit_func, 3829 3829 - MIR_new_insn(ctx, MIR_MOV, 3830 3830 - MIR_new_reg_op(ctx, r_bailout_sp), 3831 3831 - MIR_new_int_op(ctx, pre_op_sp))); 3832 3832 - MIR_append_insn(ctx, jit_func, 3833 3833 - MIR_new_insn(ctx, MIR_JMP, 3834 3834 - MIR_new_label_op(ctx, bailout_tramp))); 3888 3888 + mir_emit_bailout_jump_typed(ctx, jit_func, 3889 3889 + r_bailout_off, bc_off, 3890 3890 + r_bailout_sp, pre_op_sp, bailout_tramp, 3891 3891 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3892 3892 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3835 3893 MIR_append_insn(ctx, jit_func, skip_bail); 3836 3894 } else if (fb_num_only) { 3837 3895 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 3858 3916 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3859 3917 MIR_append_insn(ctx, jit_func, bail_direct); 3860 3918 int pre_op_sp = vs.sp + 1; 3861 3861 - for (int i = 0; i < pre_op_sp; i++) { 3862 3862 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3863 3863 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3864 3864 - MIR_append_insn(ctx, jit_func, 3865 3865 - MIR_new_insn(ctx, MIR_MOV, 3866 3866 - MIR_new_mem_op(ctx, MIR_T_I64, 3867 3867 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3868 3868 - MIR_new_reg_op(ctx, vs.regs[i]))); 3869 3869 - } 3870 3870 - for (int i = 0; i < n_locals; i++) 3871 3871 - MIR_append_insn(ctx, jit_func, 3872 3872 - MIR_new_insn(ctx, MIR_MOV, 3873 3873 - MIR_new_mem_op(ctx, MIR_T_I64, 3874 3874 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3875 3875 - MIR_new_reg_op(ctx, local_regs[i]))); 3876 3876 - MIR_append_insn(ctx, jit_func, 3877 3877 - MIR_new_insn(ctx, MIR_MOV, 3878 3878 - MIR_new_reg_op(ctx, r_bailout_off), 3879 3879 - MIR_new_int_op(ctx, bc_off))); 3880 3880 - MIR_append_insn(ctx, jit_func, 3881 3881 - MIR_new_insn(ctx, MIR_MOV, 3882 3882 - MIR_new_reg_op(ctx, r_bailout_sp), 3883 3883 - MIR_new_int_op(ctx, pre_op_sp))); 3884 3884 - MIR_append_insn(ctx, jit_func, 3885 3885 - MIR_new_insn(ctx, MIR_JMP, 3886 3886 - MIR_new_label_op(ctx, bailout_tramp))); 3919 3919 + mir_emit_bailout_jump_typed(ctx, jit_func, 3920 3920 + r_bailout_off, bc_off, 3921 3921 + r_bailout_sp, pre_op_sp, bailout_tramp, 3922 3922 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3923 3923 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3887 3924 MIR_append_insn(ctx, jit_func, skip_bail); 3888 3925 } else { 3889 3926 MIR_label_t slow = MIR_new_label(ctx); ··· 3915 3952 MIR_new_reg_op(ctx, rl))); 3916 3953 mir_call_helper2(ctx, jit_func, rd, 3917 3954 helper2_proto, imp_mul, r_vm, r_js, rl, rr); 3918 3918 - mir_emit_bailout_check(ctx, jit_func, rd, 3955 3955 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3919 3956 r_bailout_val, r_bailout_off, bc_off, 3920 3957 r_bailout_sp, vs.sp + 1, bailout_tramp, 3921 3921 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3958 3958 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3959 3959 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3922 3960 MIR_append_insn(ctx, jit_func, done); 3923 3961 } 3924 3962 break; ··· 3946 3984 mir_call_helper2(ctx, jit_func, rd, 3947 3985 helper2_proto, imp_div, 3948 3986 r_vm, r_js, rl, rr); 3949 3949 - mir_emit_bailout_check(ctx, jit_func, rd, 3987 3987 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 3950 3988 r_bailout_val, r_bailout_off, bc_off, 3951 3989 r_bailout_sp, vs.sp + 1, bailout_tramp, 3952 3952 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 3990 3990 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 3991 3991 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 3953 3992 } else if (fb_num_only && l_is_num && r_is_num) { 3954 3993 MIR_reg_t fd_r = vs.d_regs[vs.sp]; 3955 3994 MIR_reg_t fd_dst = vs.d_regs[vs.sp - 1]; ··· 3979 4018 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 3980 4019 MIR_append_insn(ctx, jit_func, bail_direct); 3981 4020 int pre_op_sp = vs.sp + 1; 3982 3982 - for (int i = 0; i < pre_op_sp; i++) { 3983 3983 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 3984 3984 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 3985 3985 - MIR_append_insn(ctx, jit_func, 3986 3986 - MIR_new_insn(ctx, MIR_MOV, 3987 3987 - MIR_new_mem_op(ctx, MIR_T_I64, 3988 3988 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 3989 3989 - MIR_new_reg_op(ctx, vs.regs[i]))); 3990 3990 - } 3991 3991 - for (int i = 0; i < n_locals; i++) 3992 3992 - MIR_append_insn(ctx, jit_func, 3993 3993 - MIR_new_insn(ctx, MIR_MOV, 3994 3994 - MIR_new_mem_op(ctx, MIR_T_I64, 3995 3995 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 3996 3996 - MIR_new_reg_op(ctx, local_regs[i]))); 3997 3997 - MIR_append_insn(ctx, jit_func, 3998 3998 - MIR_new_insn(ctx, MIR_MOV, 3999 3999 - MIR_new_reg_op(ctx, r_bailout_off), 4000 4000 - MIR_new_int_op(ctx, bc_off))); 4001 4001 - MIR_append_insn(ctx, jit_func, 4002 4002 - MIR_new_insn(ctx, MIR_MOV, 4003 4003 - MIR_new_reg_op(ctx, r_bailout_sp), 4004 4004 - MIR_new_int_op(ctx, pre_op_sp))); 4005 4005 - MIR_append_insn(ctx, jit_func, 4006 4006 - MIR_new_insn(ctx, MIR_JMP, 4007 4007 - MIR_new_label_op(ctx, bailout_tramp))); 4021 4021 + mir_emit_bailout_jump_typed(ctx, jit_func, 4022 4022 + r_bailout_off, bc_off, 4023 4023 + r_bailout_sp, pre_op_sp, bailout_tramp, 4024 4024 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4025 4025 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4008 4026 MIR_append_insn(ctx, jit_func, skip_bail); 4009 4027 } else if (fb_num_only) { 4010 4028 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 4031 4049 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 4032 4050 MIR_append_insn(ctx, jit_func, bail_direct); 4033 4051 int pre_op_sp = vs.sp + 1; 4034 4034 - for (int i = 0; i < pre_op_sp; i++) { 4035 4035 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 4036 4036 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 4037 4037 - MIR_append_insn(ctx, jit_func, 4038 4038 - MIR_new_insn(ctx, MIR_MOV, 4039 4039 - MIR_new_mem_op(ctx, MIR_T_I64, 4040 4040 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 4041 4041 - MIR_new_reg_op(ctx, vs.regs[i]))); 4042 4042 - } 4043 4043 - for (int i = 0; i < n_locals; i++) 4044 4044 - MIR_append_insn(ctx, jit_func, 4045 4045 - MIR_new_insn(ctx, MIR_MOV, 4046 4046 - MIR_new_mem_op(ctx, MIR_T_I64, 4047 4047 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 4048 4048 - MIR_new_reg_op(ctx, local_regs[i]))); 4049 4049 - MIR_append_insn(ctx, jit_func, 4050 4050 - MIR_new_insn(ctx, MIR_MOV, 4051 4051 - MIR_new_reg_op(ctx, r_bailout_off), 4052 4052 - MIR_new_int_op(ctx, bc_off))); 4053 4053 - MIR_append_insn(ctx, jit_func, 4054 4054 - MIR_new_insn(ctx, MIR_MOV, 4055 4055 - MIR_new_reg_op(ctx, r_bailout_sp), 4056 4056 - MIR_new_int_op(ctx, pre_op_sp))); 4057 4057 - MIR_append_insn(ctx, jit_func, 4058 4058 - MIR_new_insn(ctx, MIR_JMP, 4059 4059 - MIR_new_label_op(ctx, bailout_tramp))); 4052 4052 + mir_emit_bailout_jump_typed(ctx, jit_func, 4053 4053 + r_bailout_off, bc_off, 4054 4054 + r_bailout_sp, pre_op_sp, bailout_tramp, 4055 4055 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4056 4056 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4060 4057 MIR_append_insn(ctx, jit_func, skip_bail); 4061 4058 } else { 4062 4059 MIR_label_t slow = MIR_new_label(ctx); ··· 4088 4085 MIR_new_reg_op(ctx, rl))); 4089 4086 mir_call_helper2(ctx, jit_func, rd, 4090 4087 helper2_proto, imp_div, r_vm, r_js, rl, rr); 4091 4091 - mir_emit_bailout_check(ctx, jit_func, rd, 4088 4088 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 4092 4089 r_bailout_val, r_bailout_off, bc_off, 4093 4090 r_bailout_sp, vs.sp + 1, bailout_tramp, 4094 4094 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 4091 4091 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4092 4092 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4095 4093 MIR_append_insn(ctx, jit_func, done); 4096 4094 } 4097 4095 break; ··· 4234 4232 mir_call_helper2(ctx, jit_func, rd, 4235 4233 helper2_proto, imp_lt, 4236 4234 r_vm, r_js, rl, rr); 4237 4237 - mir_emit_bailout_check(ctx, jit_func, rd, 4235 4235 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 4238 4236 r_bailout_val, r_bailout_off, bc_off, 4239 4237 r_bailout_sp, vs.sp + 1, bailout_tramp, 4240 4240 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 4238 4238 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4239 4239 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4241 4240 } else if (fb_num_only && l_is_num && r_is_num) { 4242 4241 MIR_reg_t fd_l = vs.d_regs[vs.sp - 1]; 4243 4242 MIR_reg_t fd_r = vs.d_regs[vs.sp]; ··· 4283 4282 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 4284 4283 MIR_append_insn(ctx, jit_func, bail_direct); 4285 4284 int pre_op_sp = vs.sp + 1; 4286 4286 - for (int i = 0; i < pre_op_sp; i++) { 4287 4287 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 4288 4288 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 4289 4289 - MIR_append_insn(ctx, jit_func, 4290 4290 - MIR_new_insn(ctx, MIR_MOV, 4291 4291 - MIR_new_mem_op(ctx, MIR_T_I64, 4292 4292 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 4293 4293 - MIR_new_reg_op(ctx, vs.regs[i]))); 4294 4294 - } 4295 4295 - for (int i = 0; i < n_locals; i++) 4296 4296 - MIR_append_insn(ctx, jit_func, 4297 4297 - MIR_new_insn(ctx, MIR_MOV, 4298 4298 - MIR_new_mem_op(ctx, MIR_T_I64, 4299 4299 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 4300 4300 - MIR_new_reg_op(ctx, local_regs[i]))); 4301 4301 - MIR_append_insn(ctx, jit_func, 4302 4302 - MIR_new_insn(ctx, MIR_MOV, 4303 4303 - MIR_new_reg_op(ctx, r_bailout_off), 4304 4304 - MIR_new_int_op(ctx, bc_off))); 4305 4305 - MIR_append_insn(ctx, jit_func, 4306 4306 - MIR_new_insn(ctx, MIR_MOV, 4307 4307 - MIR_new_reg_op(ctx, r_bailout_sp), 4308 4308 - MIR_new_int_op(ctx, pre_op_sp))); 4309 4309 - MIR_append_insn(ctx, jit_func, 4310 4310 - MIR_new_insn(ctx, MIR_JMP, 4311 4311 - MIR_new_label_op(ctx, bailout_tramp))); 4285 4285 + mir_emit_bailout_jump_typed(ctx, jit_func, 4286 4286 + r_bailout_off, bc_off, 4287 4287 + r_bailout_sp, pre_op_sp, bailout_tramp, 4288 4288 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4289 4289 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4312 4290 MIR_append_insn(ctx, jit_func, skip_bail); 4313 4291 } else if (fb_num_only) { 4314 4292 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 4341 4319 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 4342 4320 MIR_append_insn(ctx, jit_func, bail_direct); 4343 4321 int pre_op_sp = vs.sp + 1; 4344 4344 - for (int i = 0; i < pre_op_sp; i++) 4345 4345 - MIR_append_insn(ctx, jit_func, 4346 4346 - MIR_new_insn(ctx, MIR_MOV, 4347 4347 - MIR_new_mem_op(ctx, MIR_T_I64, 4348 4348 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 4349 4349 - MIR_new_reg_op(ctx, vs.regs[i]))); 4350 4350 - for (int i = 0; i < n_locals; i++) 4351 4351 - MIR_append_insn(ctx, jit_func, 4352 4352 - MIR_new_insn(ctx, MIR_MOV, 4353 4353 - MIR_new_mem_op(ctx, MIR_T_I64, 4354 4354 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 4355 4355 - MIR_new_reg_op(ctx, local_regs[i]))); 4356 4356 - MIR_append_insn(ctx, jit_func, 4357 4357 - MIR_new_insn(ctx, MIR_MOV, 4358 4358 - MIR_new_reg_op(ctx, r_bailout_off), 4359 4359 - MIR_new_int_op(ctx, bc_off))); 4360 4360 - MIR_append_insn(ctx, jit_func, 4361 4361 - MIR_new_insn(ctx, MIR_MOV, 4362 4362 - MIR_new_reg_op(ctx, r_bailout_sp), 4363 4363 - MIR_new_int_op(ctx, pre_op_sp))); 4364 4364 - MIR_append_insn(ctx, jit_func, 4365 4365 - MIR_new_insn(ctx, MIR_JMP, 4366 4366 - MIR_new_label_op(ctx, bailout_tramp))); 4322 4322 + mir_emit_bailout_jump_typed(ctx, jit_func, 4323 4323 + r_bailout_off, bc_off, 4324 4324 + r_bailout_sp, pre_op_sp, bailout_tramp, 4325 4325 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4326 4326 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4367 4327 MIR_append_insn(ctx, jit_func, skip_bail); 4368 4328 } else { 4369 4329 MIR_label_t slow = MIR_new_label(ctx); ··· 4401 4361 MIR_new_reg_op(ctx, rl))); 4402 4362 mir_call_helper2(ctx, jit_func, rd, 4403 4363 helper2_proto, imp_lt, r_vm, r_js, rl, rr); 4404 4404 - mir_emit_bailout_check(ctx, jit_func, rd, 4364 4364 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 4405 4365 r_bailout_val, r_bailout_off, bc_off, 4406 4366 r_bailout_sp, vs.sp + 1, bailout_tramp, 4407 4407 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 4367 4367 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4368 4368 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4408 4369 MIR_append_insn(ctx, jit_func, done); 4409 4370 } 4410 4371 break; ··· 4430 4391 mir_call_helper2(ctx, jit_func, rd, 4431 4392 helper2_proto, imp_le, 4432 4393 r_vm, r_js, rl, rr); 4433 4433 - mir_emit_bailout_check(ctx, jit_func, rd, 4394 4394 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 4434 4395 r_bailout_val, r_bailout_off, bc_off, 4435 4396 r_bailout_sp, vs.sp + 1, bailout_tramp, 4436 4436 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 4397 4397 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4398 4398 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4437 4399 } else if (fb_num_only && l_is_num && r_is_num) { 4438 4400 MIR_reg_t fd_l = vs.d_regs[vs.sp - 1]; 4439 4401 MIR_reg_t fd_r = vs.d_regs[vs.sp]; ··· 4479 4441 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 4480 4442 MIR_append_insn(ctx, jit_func, bail_direct); 4481 4443 int pre_op_sp = vs.sp + 1; 4482 4482 - for (int i = 0; i < pre_op_sp; i++) { 4483 4483 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 4484 4484 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 4485 4485 - MIR_append_insn(ctx, jit_func, 4486 4486 - MIR_new_insn(ctx, MIR_MOV, 4487 4487 - MIR_new_mem_op(ctx, MIR_T_I64, 4488 4488 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 4489 4489 - MIR_new_reg_op(ctx, vs.regs[i]))); 4490 4490 - } 4491 4491 - for (int i = 0; i < n_locals; i++) 4492 4492 - MIR_append_insn(ctx, jit_func, 4493 4493 - MIR_new_insn(ctx, MIR_MOV, 4494 4494 - MIR_new_mem_op(ctx, MIR_T_I64, 4495 4495 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 4496 4496 - MIR_new_reg_op(ctx, local_regs[i]))); 4497 4497 - MIR_append_insn(ctx, jit_func, 4498 4498 - MIR_new_insn(ctx, MIR_MOV, 4499 4499 - MIR_new_reg_op(ctx, r_bailout_off), 4500 4500 - MIR_new_int_op(ctx, bc_off))); 4501 4501 - MIR_append_insn(ctx, jit_func, 4502 4502 - MIR_new_insn(ctx, MIR_MOV, 4503 4503 - MIR_new_reg_op(ctx, r_bailout_sp), 4504 4504 - MIR_new_int_op(ctx, pre_op_sp))); 4505 4505 - MIR_append_insn(ctx, jit_func, 4506 4506 - MIR_new_insn(ctx, MIR_JMP, 4507 4507 - MIR_new_label_op(ctx, bailout_tramp))); 4444 4444 + mir_emit_bailout_jump_typed(ctx, jit_func, 4445 4445 + r_bailout_off, bc_off, 4446 4446 + r_bailout_sp, pre_op_sp, bailout_tramp, 4447 4447 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4448 4448 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4508 4449 MIR_append_insn(ctx, jit_func, skip_bail); 4509 4450 } else if (fb_num_only) { 4510 4451 MIR_label_t bail_direct = MIR_new_label(ctx); ··· 4537 4478 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 4538 4479 MIR_append_insn(ctx, jit_func, bail_direct); 4539 4480 int pre_op_sp = vs.sp + 1; 4540 4540 - for (int i = 0; i < pre_op_sp; i++) 4541 4541 - MIR_append_insn(ctx, jit_func, 4542 4542 - MIR_new_insn(ctx, MIR_MOV, 4543 4543 - MIR_new_mem_op(ctx, MIR_T_I64, 4544 4544 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 4545 4545 - MIR_new_reg_op(ctx, vs.regs[i]))); 4546 4546 - for (int i = 0; i < n_locals; i++) 4547 4547 - MIR_append_insn(ctx, jit_func, 4548 4548 - MIR_new_insn(ctx, MIR_MOV, 4549 4549 - MIR_new_mem_op(ctx, MIR_T_I64, 4550 4550 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 4551 4551 - MIR_new_reg_op(ctx, local_regs[i]))); 4552 4552 - MIR_append_insn(ctx, jit_func, 4553 4553 - MIR_new_insn(ctx, MIR_MOV, 4554 4554 - MIR_new_reg_op(ctx, r_bailout_off), 4555 4555 - MIR_new_int_op(ctx, bc_off))); 4556 4556 - MIR_append_insn(ctx, jit_func, 4557 4557 - MIR_new_insn(ctx, MIR_MOV, 4558 4558 - MIR_new_reg_op(ctx, r_bailout_sp), 4559 4559 - MIR_new_int_op(ctx, pre_op_sp))); 4560 4560 - MIR_append_insn(ctx, jit_func, 4561 4561 - MIR_new_insn(ctx, MIR_JMP, 4562 4562 - MIR_new_label_op(ctx, bailout_tramp))); 4481 4481 + mir_emit_bailout_jump_typed(ctx, jit_func, 4482 4482 + r_bailout_off, bc_off, 4483 4483 + r_bailout_sp, pre_op_sp, bailout_tramp, 4484 4484 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4485 4485 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4563 4486 MIR_append_insn(ctx, jit_func, skip_bail); 4564 4487 } else { 4565 4488 MIR_label_t slow = MIR_new_label(ctx); ··· 4597 4520 MIR_new_reg_op(ctx, rl))); 4598 4521 mir_call_helper2(ctx, jit_func, rd, 4599 4522 helper2_proto, imp_le, r_vm, r_js, rl, rr); 4600 4600 - mir_emit_bailout_check(ctx, jit_func, rd, 4523 4523 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 4601 4524 r_bailout_val, r_bailout_off, bc_off, 4602 4525 r_bailout_sp, vs.sp + 1, bailout_tramp, 4603 4603 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 4526 4526 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 4527 4527 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 4604 4528 MIR_append_insn(ctx, jit_func, done); 4605 4529 } 4606 4530 break; ··· 7067 6991 mir_call_helper2(ctx, jit_func, rd, 7068 6992 helper2_proto, imp_gt, 7069 6993 r_vm, r_js, rl, rr); 7070 7070 - mir_emit_bailout_check(ctx, jit_func, rd, 6994 6994 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 7071 6995 r_bailout_val, r_bailout_off, bc_off, 7072 6996 r_bailout_sp, vs.sp + 1, bailout_tramp, 7073 7073 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 6997 6997 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 6998 6998 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7074 6999 } else if (fb_num_only && l_is_num && r_is_num) { 7075 7000 MIR_reg_t fd_l = vs.d_regs[vs.sp - 1]; 7076 7001 MIR_reg_t fd_r = vs.d_regs[vs.sp]; ··· 7116 7041 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 7117 7042 MIR_append_insn(ctx, jit_func, bail_direct); 7118 7043 int pre_op_sp = vs.sp + 1; 7119 7119 - for (int i = 0; i < pre_op_sp; i++) { 7120 7120 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 7121 7121 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 7122 7122 - MIR_append_insn(ctx, jit_func, 7123 7123 - MIR_new_insn(ctx, MIR_MOV, 7124 7124 - MIR_new_mem_op(ctx, MIR_T_I64, 7125 7125 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 7126 7126 - MIR_new_reg_op(ctx, vs.regs[i]))); 7127 7127 - } 7128 7128 - for (int i = 0; i < n_locals; i++) 7129 7129 - MIR_append_insn(ctx, jit_func, 7130 7130 - MIR_new_insn(ctx, MIR_MOV, 7131 7131 - MIR_new_mem_op(ctx, MIR_T_I64, 7132 7132 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 7133 7133 - MIR_new_reg_op(ctx, local_regs[i]))); 7134 7134 - MIR_append_insn(ctx, jit_func, 7135 7135 - MIR_new_insn(ctx, MIR_MOV, 7136 7136 - MIR_new_reg_op(ctx, r_bailout_off), 7137 7137 - MIR_new_int_op(ctx, bc_off))); 7138 7138 - MIR_append_insn(ctx, jit_func, 7139 7139 - MIR_new_insn(ctx, MIR_MOV, 7140 7140 - MIR_new_reg_op(ctx, r_bailout_sp), 7141 7141 - MIR_new_int_op(ctx, pre_op_sp))); 7142 7142 - MIR_append_insn(ctx, jit_func, 7143 7143 - MIR_new_insn(ctx, MIR_JMP, 7144 7144 - MIR_new_label_op(ctx, bailout_tramp))); 7044 7044 + mir_emit_bailout_jump_typed(ctx, jit_func, 7045 7045 + r_bailout_off, bc_off, 7046 7046 + r_bailout_sp, pre_op_sp, bailout_tramp, 7047 7047 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 7048 7048 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7145 7049 MIR_append_insn(ctx, jit_func, skip_bail); 7146 7050 } else { 7147 7051 MIR_label_t slow = MIR_new_label(ctx); ··· 7179 7083 MIR_new_reg_op(ctx, rl))); 7180 7084 mir_call_helper2(ctx, jit_func, rd, 7181 7085 helper2_proto, imp_gt, r_vm, r_js, rl, rr); 7182 7182 - mir_emit_bailout_check(ctx, jit_func, rd, 7086 7086 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 7183 7087 r_bailout_val, r_bailout_off, bc_off, 7184 7088 r_bailout_sp, vs.sp + 1, bailout_tramp, 7185 7185 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 7089 7089 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 7090 7090 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7186 7091 MIR_append_insn(ctx, jit_func, done); 7187 7092 } 7188 7093 break; ··· 7208 7113 mir_call_helper2(ctx, jit_func, rd, 7209 7114 helper2_proto, imp_ge, 7210 7115 r_vm, r_js, rl, rr); 7211 7211 - mir_emit_bailout_check(ctx, jit_func, rd, 7116 7116 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 7212 7117 r_bailout_val, r_bailout_off, bc_off, 7213 7118 r_bailout_sp, vs.sp + 1, bailout_tramp, 7214 7214 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 7119 7119 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 7120 7120 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7215 7121 } else if (fb_num_only && l_is_num && r_is_num) { 7216 7122 MIR_reg_t fd_l = vs.d_regs[vs.sp - 1]; 7217 7123 MIR_reg_t fd_r = vs.d_regs[vs.sp]; ··· 7257 7163 MIR_new_insn(ctx, MIR_JMP, MIR_new_label_op(ctx, skip_bail))); 7258 7164 MIR_append_insn(ctx, jit_func, bail_direct); 7259 7165 int pre_op_sp = vs.sp + 1; 7260 7260 - for (int i = 0; i < pre_op_sp; i++) { 7261 7261 - if (vs.slot_type && vs.slot_type[i] == SLOT_NUM) 7262 7262 - mir_d_to_i64(ctx, jit_func, vs.regs[i], vs.d_regs[i], r_d_slot); 7263 7263 - MIR_append_insn(ctx, jit_func, 7264 7264 - MIR_new_insn(ctx, MIR_MOV, 7265 7265 - MIR_new_mem_op(ctx, MIR_T_I64, 7266 7266 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_args_buf, 0, 1), 7267 7267 - MIR_new_reg_op(ctx, vs.regs[i]))); 7268 7268 - } 7269 7269 - for (int i = 0; i < n_locals; i++) 7270 7270 - MIR_append_insn(ctx, jit_func, 7271 7271 - MIR_new_insn(ctx, MIR_MOV, 7272 7272 - MIR_new_mem_op(ctx, MIR_T_I64, 7273 7273 - (MIR_disp_t)(i * (int)sizeof(ant_value_t)), r_lbuf, 0, 1), 7274 7274 - MIR_new_reg_op(ctx, local_regs[i]))); 7275 7275 - MIR_append_insn(ctx, jit_func, 7276 7276 - MIR_new_insn(ctx, MIR_MOV, 7277 7277 - MIR_new_reg_op(ctx, r_bailout_off), 7278 7278 - MIR_new_int_op(ctx, bc_off))); 7279 7279 - MIR_append_insn(ctx, jit_func, 7280 7280 - MIR_new_insn(ctx, MIR_MOV, 7281 7281 - MIR_new_reg_op(ctx, r_bailout_sp), 7282 7282 - MIR_new_int_op(ctx, pre_op_sp))); 7283 7283 - MIR_append_insn(ctx, jit_func, 7284 7284 - MIR_new_insn(ctx, MIR_JMP, 7285 7285 - MIR_new_label_op(ctx, bailout_tramp))); 7166 7166 + mir_emit_bailout_jump_typed(ctx, jit_func, 7167 7167 + r_bailout_off, bc_off, 7168 7168 + r_bailout_sp, pre_op_sp, bailout_tramp, 7169 7169 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 7170 7170 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7286 7171 MIR_append_insn(ctx, jit_func, skip_bail); 7287 7172 } else { 7288 7173 MIR_label_t slow = MIR_new_label(ctx); ··· 7320 7205 MIR_new_reg_op(ctx, rl))); 7321 7206 mir_call_helper2(ctx, jit_func, rd, 7322 7207 helper2_proto, imp_ge, r_vm, r_js, rl, rr); 7323 7323 - mir_emit_bailout_check(ctx, jit_func, rd, 7208 7208 + mir_emit_bailout_check_typed(ctx, jit_func, rd, 7324 7209 r_bailout_val, r_bailout_off, bc_off, 7325 7210 r_bailout_sp, vs.sp + 1, bailout_tramp, 7326 7326 - r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot); 7211 7211 + r_args_buf, &vs, local_regs, n_locals, r_lbuf, r_d_slot, 7212 7212 + vs.sp - 1, l_is_num, vs.sp, r_is_num); 7327 7213 MIR_append_insn(ctx, jit_func, done); 7328 7214 } 7329 7215 break;