2 ** Fast function call recorder.
3 ** Copyright (C) 2005-2016 Mike Pall. See Copyright Notice in luajit.h
21 #include "lj_ircall.h"
24 #include "lj_record.h"
25 #include "lj_ffrecord.h"
26 #include "lj_crecord.h"
27 #include "lj_dispatch.h"
29 #include "lj_strscan.h"
30 #include "lj_strfmt.h"
32 /* Some local macros to save typing. Undef'd at the end. */
33 #define IR(ref) (&J->cur.ir[(ref)])
35 /* Pass IR on to next optimization in chain (FOLD). */
36 #define emitir(ot, a, b) (lj_ir_set(J, (ot), (a), (b)), lj_opt_fold(J))
38 /* -- Fast function recording handlers ------------------------------------ */
40 /* Conventions for fast function call handlers:
42 ** The argument slots start at J->base[0]. All of them are guaranteed to be
43 ** valid and type-specialized references. J->base[J->maxslot] is set to 0
44 ** as a sentinel. The runtime argument values start at rd->argv[0].
46 ** In general fast functions should check for presence of all of their
47 ** arguments and for the correct argument types. Some simplifications
48 ** are allowed if the interpreter throws instead. But even if recording
49 ** is aborted, the generated IR must be consistent (no zero-refs).
51 ** The number of results in rd->nres is set to 1. Handlers that return
52 ** a different number of results need to override it. A negative value
53 ** prevents return processing (e.g. for pending calls).
55 ** Results need to be stored starting at J->base[0]. Return processing
56 ** moves them to the right slots later.
58 ** The per-ffid auxiliary data is the value of the 2nd part of the
59 ** LJLIB_REC() annotation. This allows handling similar functionality
60 ** in a common handler.
63 /* Type of handler to record a fast function. */
64 typedef void (LJ_FASTCALL
*RecordFunc
)(jit_State
*J
, RecordFFData
*rd
);
66 /* Get runtime value of int argument. */
67 static int32_t argv2int(jit_State
*J
, TValue
*o
)
69 if (!lj_strscan_numberobj(o
))
70 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
71 return tvisint(o
) ? intV(o
) : lj_num2int(numV(o
));
74 /* Get runtime value of string argument. */
75 static GCstr
*argv2str(jit_State
*J
, TValue
*o
)
77 if (LJ_LIKELY(tvisstr(o
))) {
82 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
83 s
= lj_strfmt_number(J
->L
, o
);
89 /* Return number of results wanted by caller. */
90 static ptrdiff_t results_wanted(jit_State
*J
)
92 TValue
*frame
= J
->L
->base
-1;
93 if (frame_islua(frame
))
94 return (ptrdiff_t)bc_b(frame_pc(frame
)[-1]) - 1;
99 /* Trace stitching: add continuation below frame to start a new trace. */
100 static void recff_stitch(jit_State
*J
)
102 ASMFunction cont
= lj_cont_stitch
;
104 TValue
*base
= L
->base
;
105 const BCIns
*pc
= frame_pc(base
-1);
106 TValue
*pframe
= frame_prevl(base
-1);
109 lua_assert(!LJ_FR2
); /* TODO_FR2: handle frame shift. */
110 /* Move func + args up in Lua stack and insert continuation. */
111 memmove(&base
[1], &base
[-1], sizeof(TValue
)*(J
->maxslot
+1));
112 setframe_ftsz(base
+1, ((char *)(base
+1) - (char *)pframe
) + FRAME_CONT
);
114 setframe_pc(base
, pc
);
115 setnilV(base
-1); /* Incorrect, but rec_check_slots() won't run anymore. */
119 /* Ditto for the IR. */
120 memmove(&J
->base
[1], &J
->base
[-1], sizeof(TRef
)*(J
->maxslot
+1));
122 trcont
= lj_ir_kptr(J
, (void *)((int64_t)cont
-(int64_t)lj_vm_asm_begin
));
124 trcont
= lj_ir_kptr(J
, (void *)cont
);
126 J
->base
[0] = trcont
| TREF_CONT
;
127 J
->ktracep
= lj_ir_k64_reserve(J
);
128 lua_assert(irt_toitype_(IRT_P64
) == LJ_TTRACE
);
129 J
->base
[-1] = emitir(IRT(IR_XLOAD
, IRT_P64
), lj_ir_kptr(J
, &J
->ktracep
->gcr
), 0);
134 lj_record_stop(J
, LJ_TRLINK_STITCH
, 0);
136 /* Undo Lua stack changes. */
137 memmove(&base
[-1], &base
[1], sizeof(TValue
)*(J
->maxslot
+1));
138 setframe_pc(base
-1, pc
);
143 /* Fallback handler for fast functions that are not recorded (yet). */
144 static void LJ_FASTCALL
recff_nyi(jit_State
*J
, RecordFFData
*rd
)
146 if (J
->cur
.nins
< (IRRef
)J
->param
[JIT_P_minstitch
] + REF_BASE
) {
147 lj_trace_err_info(J
, LJ_TRERR_TRACEUV
);
149 /* Can only stitch from Lua call. */
150 if (J
->framedepth
&& frame_islua(J
->L
->base
-1)) {
151 BCOp op
= bc_op(*frame_pc(J
->L
->base
-1));
152 /* Stitched trace cannot start with *M op with variable # of args. */
153 if (!(op
== BC_CALLM
|| op
== BC_CALLMT
||
154 op
== BC_RETM
|| op
== BC_TSETM
)) {
155 switch (J
->fn
->c
.ffid
) {
157 case FF_debug_sethook
:
159 break; /* Don't stitch across special builtins. */
161 recff_stitch(J
); /* Use trace stitching. */
167 /* Otherwise stop trace and return to interpreter. */
168 lj_record_stop(J
, LJ_TRLINK_RETURN
, 0);
173 /* Fallback handler for unsupported variants of fast functions. */
174 #define recff_nyiu recff_nyi
176 /* Must stop the trace for classic C functions with arbitrary side-effects. */
177 #define recff_c recff_nyi
179 /* Emit BUFHDR for the global temporary buffer. */
180 static TRef
recff_bufhdr(jit_State
*J
)
182 return emitir(IRT(IR_BUFHDR
, IRT_P32
),
183 lj_ir_kptr(J
, &J2G(J
)->tmpbuf
), IRBUFHDR_RESET
);
186 /* -- Base library fast functions ----------------------------------------- */
188 static void LJ_FASTCALL
recff_assert(jit_State
*J
, RecordFFData
*rd
)
190 /* Arguments already specialized. The interpreter throws for nil/false. */
191 rd
->nres
= J
->maxslot
; /* Pass through all arguments. */
194 static void LJ_FASTCALL
recff_type(jit_State
*J
, RecordFFData
*rd
)
196 /* Arguments already specialized. Result is a constant string. Neat, huh? */
198 if (tvisnumber(&rd
->argv
[0]))
200 else if (LJ_64
&& !LJ_GC64
&& tvislightud(&rd
->argv
[0]))
203 t
= ~itype(&rd
->argv
[0]);
204 J
->base
[0] = lj_ir_kstr(J
, strV(&J
->fn
->c
.upvalue
[t
]));
208 static void LJ_FASTCALL
recff_getmetatable(jit_State
*J
, RecordFFData
*rd
)
210 TRef tr
= J
->base
[0];
214 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
215 if (lj_record_mm_lookup(J
, &ix
, MM_metatable
))
216 J
->base
[0] = ix
.mobj
;
219 } /* else: Interpreter will throw. */
222 static void LJ_FASTCALL
recff_setmetatable(jit_State
*J
, RecordFFData
*rd
)
224 TRef tr
= J
->base
[0];
225 TRef mt
= J
->base
[1];
226 if (tref_istab(tr
) && (tref_istab(mt
) || (mt
&& tref_isnil(mt
)))) {
230 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
231 lj_record_mm_lookup(J
, &ix
, MM_metatable
); /* Guard for no __metatable. */
232 fref
= emitir(IRT(IR_FREF
, IRT_P32
), tr
, IRFL_TAB_META
);
233 mtref
= tref_isnil(mt
) ? lj_ir_knull(J
, IRT_TAB
) : mt
;
234 emitir(IRT(IR_FSTORE
, IRT_TAB
), fref
, mtref
);
236 emitir(IRT(IR_TBAR
, IRT_TAB
), tr
, 0);
239 } /* else: Interpreter will throw. */
242 static void LJ_FASTCALL
recff_rawget(jit_State
*J
, RecordFFData
*rd
)
245 ix
.tab
= J
->base
[0]; ix
.key
= J
->base
[1];
246 if (tref_istab(ix
.tab
) && ix
.key
) {
247 ix
.val
= 0; ix
.idxchain
= 0;
248 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
249 copyTV(J
->L
, &ix
.keyv
, &rd
->argv
[1]);
250 J
->base
[0] = lj_record_idx(J
, &ix
);
251 } /* else: Interpreter will throw. */
254 static void LJ_FASTCALL
recff_rawset(jit_State
*J
, RecordFFData
*rd
)
257 ix
.tab
= J
->base
[0]; ix
.key
= J
->base
[1]; ix
.val
= J
->base
[2];
258 if (tref_istab(ix
.tab
) && ix
.key
&& ix
.val
) {
260 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
261 copyTV(J
->L
, &ix
.keyv
, &rd
->argv
[1]);
262 copyTV(J
->L
, &ix
.valv
, &rd
->argv
[2]);
263 lj_record_idx(J
, &ix
);
264 /* Pass through table at J->base[0] as result. */
265 } /* else: Interpreter will throw. */
268 static void LJ_FASTCALL
recff_rawequal(jit_State
*J
, RecordFFData
*rd
)
270 TRef tra
= J
->base
[0];
271 TRef trb
= J
->base
[1];
273 int diff
= lj_record_objcmp(J
, tra
, trb
, &rd
->argv
[0], &rd
->argv
[1]);
274 J
->base
[0] = diff
? TREF_FALSE
: TREF_TRUE
;
275 } /* else: Interpreter will throw. */
279 static void LJ_FASTCALL
recff_rawlen(jit_State
*J
, RecordFFData
*rd
)
281 TRef tr
= J
->base
[0];
283 J
->base
[0] = emitir(IRTI(IR_FLOAD
), tr
, IRFL_STR_LEN
);
284 else if (tref_istab(tr
))
285 J
->base
[0] = lj_ir_call(J
, IRCALL_lj_tab_len
, tr
);
286 /* else: Interpreter will throw. */
291 /* Determine mode of select() call. */
292 int32_t lj_ffrecord_select_mode(jit_State
*J
, TRef tr
, TValue
*tv
)
294 if (tref_isstr(tr
) && *strVdata(tv
) == '#') { /* select('#', ...) */
295 if (strV(tv
)->len
== 1) {
296 emitir(IRTG(IR_EQ
, IRT_STR
), tr
, lj_ir_kstr(J
, strV(tv
)));
298 TRef trptr
= emitir(IRT(IR_STRREF
, IRT_P32
), tr
, lj_ir_kint(J
, 0));
299 TRef trchar
= emitir(IRT(IR_XLOAD
, IRT_U8
), trptr
, IRXLOAD_READONLY
);
300 emitir(IRTG(IR_EQ
, IRT_INT
), trchar
, lj_ir_kint(J
, '#'));
303 } else { /* select(n, ...) */
304 int32_t start
= argv2int(J
, tv
);
305 if (start
== 0) lj_trace_err(J
, LJ_TRERR_BADTYPE
); /* A bit misleading. */
310 static void LJ_FASTCALL
recff_select(jit_State
*J
, RecordFFData
*rd
)
312 TRef tr
= J
->base
[0];
314 ptrdiff_t start
= lj_ffrecord_select_mode(J
, tr
, &rd
->argv
[0]);
315 if (start
== 0) { /* select('#', ...) */
316 J
->base
[0] = lj_ir_kint(J
, J
->maxslot
- 1);
317 } else if (tref_isk(tr
)) { /* select(k, ...) */
318 ptrdiff_t n
= (ptrdiff_t)J
->maxslot
;
319 if (start
< 0) start
+= n
;
320 else if (start
> n
) start
= n
;
321 rd
->nres
= n
- start
;
324 for (i
= 0; i
< n
- start
; i
++)
325 J
->base
[i
] = J
->base
[start
+i
];
326 } /* else: Interpreter will throw. */
331 } /* else: Interpreter will throw. */
334 static void LJ_FASTCALL
recff_tonumber(jit_State
*J
, RecordFFData
*rd
)
336 TRef tr
= J
->base
[0];
337 TRef base
= J
->base
[1];
338 if (tr
&& !tref_isnil(base
)) {
339 base
= lj_opt_narrow_toint(J
, base
);
340 if (!tref_isk(base
) || IR(tref_ref(base
))->i
!= 10) {
345 if (tref_isnumber_str(tr
)) {
346 if (tref_isstr(tr
)) {
348 if (!lj_strscan_num(strV(&rd
->argv
[0]), &tmp
)) {
349 recff_nyiu(J
, rd
); /* Would need an inverted STRTO for this case. */
352 tr
= emitir(IRTG(IR_STRTO
, IRT_NUM
), tr
, 0);
355 } else if (tref_iscdata(tr
)) {
356 lj_crecord_tonumber(J
, rd
);
366 static TValue
*recff_metacall_cp(lua_State
*L
, lua_CFunction dummy
, void *ud
)
368 jit_State
*J
= (jit_State
*)ud
;
369 lj_record_tailcall(J
, 0, 1);
370 UNUSED(L
); UNUSED(dummy
);
374 static int recff_metacall(jit_State
*J
, RecordFFData
*rd
, MMS mm
)
378 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
379 if (lj_record_mm_lookup(J
, &ix
, mm
)) { /* Has metamethod? */
382 /* Temporarily insert metamethod below object. */
383 J
->base
[1] = J
->base
[0];
384 J
->base
[0] = ix
.mobj
;
385 copyTV(J
->L
, &argv0
, &rd
->argv
[0]);
386 copyTV(J
->L
, &rd
->argv
[1], &rd
->argv
[0]);
387 copyTV(J
->L
, &rd
->argv
[0], &ix
.mobjv
);
388 /* Need to protect lj_record_tailcall because it may throw. */
389 errcode
= lj_vm_cpcall(J
->L
, NULL
, J
, recff_metacall_cp
);
390 /* Always undo Lua stack changes to avoid confusing the interpreter. */
391 copyTV(J
->L
, &rd
->argv
[0], &argv0
);
393 lj_err_throw(J
->L
, errcode
); /* Propagate errors. */
394 rd
->nres
= -1; /* Pending call. */
395 return 1; /* Tailcalled to metamethod. */
400 static void LJ_FASTCALL
recff_tostring(jit_State
*J
, RecordFFData
*rd
)
402 TRef tr
= J
->base
[0];
403 if (tref_isstr(tr
)) {
404 /* Ignore __tostring in the string base metatable. */
405 /* Pass on result in J->base[0]. */
406 } else if (tr
&& !recff_metacall(J
, rd
, MM_tostring
)) {
407 if (tref_isnumber(tr
)) {
408 J
->base
[0] = emitir(IRT(IR_TOSTR
, IRT_STR
), tr
,
409 tref_isnum(tr
) ? IRTOSTR_NUM
: IRTOSTR_INT
);
410 } else if (tref_ispri(tr
)) {
411 J
->base
[0] = lj_ir_kstr(J
, lj_strfmt_obj(J
->L
, &rd
->argv
[0]));
419 static void LJ_FASTCALL
recff_ipairs_aux(jit_State
*J
, RecordFFData
*rd
)
423 if (tref_istab(ix
.tab
)) {
424 if (!tvisnumber(&rd
->argv
[1])) /* No support for string coercion. */
425 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
426 setintV(&ix
.keyv
, numberVint(&rd
->argv
[1])+1);
427 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
428 ix
.val
= 0; ix
.idxchain
= 0;
429 ix
.key
= lj_opt_narrow_toint(J
, J
->base
[1]);
430 J
->base
[0] = ix
.key
= emitir(IRTI(IR_ADD
), ix
.key
, lj_ir_kint(J
, 1));
431 J
->base
[1] = lj_record_idx(J
, &ix
);
432 rd
->nres
= tref_isnil(J
->base
[1]) ? 0 : 2;
433 } /* else: Interpreter will throw. */
436 static void LJ_FASTCALL
recff_xpairs(jit_State
*J
, RecordFFData
*rd
)
438 TRef tr
= J
->base
[0];
439 if (!((LJ_52
|| (LJ_HASFFI
&& tref_iscdata(tr
))) &&
440 recff_metacall(J
, rd
, MM_pairs
+ rd
->data
))) {
441 if (tref_istab(tr
)) {
442 J
->base
[0] = lj_ir_kfunc(J
, funcV(&J
->fn
->c
.upvalue
[0]));
444 J
->base
[2] = rd
->data
? lj_ir_kint(J
, 0) : TREF_NIL
;
446 } /* else: Interpreter will throw. */
450 static void LJ_FASTCALL
recff_pcall(jit_State
*J
, RecordFFData
*rd
)
452 if (J
->maxslot
>= 1) {
453 lj_record_call(J
, 0, J
->maxslot
- 1);
454 rd
->nres
= -1; /* Pending call. */
455 } /* else: Interpreter will throw. */
458 static TValue
*recff_xpcall_cp(lua_State
*L
, lua_CFunction dummy
, void *ud
)
460 jit_State
*J
= (jit_State
*)ud
;
461 lj_record_call(J
, 1, J
->maxslot
- 2);
462 UNUSED(L
); UNUSED(dummy
);
466 static void LJ_FASTCALL
recff_xpcall(jit_State
*J
, RecordFFData
*rd
)
468 if (J
->maxslot
>= 2) {
472 lua_assert(!LJ_FR2
); /* TODO_FR2: handle different frame setup. */
473 /* Swap function and traceback. */
474 tmp
= J
->base
[0]; J
->base
[0] = J
->base
[1]; J
->base
[1] = tmp
;
475 copyTV(J
->L
, &argv0
, &rd
->argv
[0]);
476 copyTV(J
->L
, &argv1
, &rd
->argv
[1]);
477 copyTV(J
->L
, &rd
->argv
[0], &argv1
);
478 copyTV(J
->L
, &rd
->argv
[1], &argv0
);
479 /* Need to protect lj_record_call because it may throw. */
480 errcode
= lj_vm_cpcall(J
->L
, NULL
, J
, recff_xpcall_cp
);
481 /* Always undo Lua stack swap to avoid confusing the interpreter. */
482 copyTV(J
->L
, &rd
->argv
[0], &argv0
);
483 copyTV(J
->L
, &rd
->argv
[1], &argv1
);
485 lj_err_throw(J
->L
, errcode
); /* Propagate errors. */
486 rd
->nres
= -1; /* Pending call. */
487 } /* else: Interpreter will throw. */
490 static void LJ_FASTCALL
recff_getfenv(jit_State
*J
, RecordFFData
*rd
)
492 TRef tr
= J
->base
[0];
493 /* Only support getfenv(0) for now. */
494 if (tref_isint(tr
) && tref_isk(tr
) && IR(tref_ref(tr
))->i
== 0) {
495 TRef trl
= emitir(IRT(IR_LREF
, IRT_THREAD
), 0, 0);
496 J
->base
[0] = emitir(IRT(IR_FLOAD
, IRT_TAB
), trl
, IRFL_THREAD_ENV
);
502 /* -- Math library fast functions ----------------------------------------- */
504 static void LJ_FASTCALL
recff_math_abs(jit_State
*J
, RecordFFData
*rd
)
506 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
507 J
->base
[0] = emitir(IRTN(IR_ABS
), tr
, lj_ir_knum_abs(J
));
511 /* Record rounding functions math.floor and math.ceil. */
512 static void LJ_FASTCALL
recff_math_round(jit_State
*J
, RecordFFData
*rd
)
514 TRef tr
= J
->base
[0];
515 if (!tref_isinteger(tr
)) { /* Pass through integers unmodified. */
516 tr
= emitir(IRTN(IR_FPMATH
), lj_ir_tonum(J
, tr
), rd
->data
);
517 /* Result is integral (or NaN/Inf), but may not fit an int32_t. */
518 if (LJ_DUALNUM
) { /* Try to narrow using a guarded conversion to int. */
519 lua_Number n
= lj_vm_foldfpm(numberVnum(&rd
->argv
[0]), rd
->data
);
520 if (n
== (lua_Number
)lj_num2int(n
))
521 tr
= emitir(IRTGI(IR_CONV
), tr
, IRCONV_INT_NUM
|IRCONV_CHECK
);
527 /* Record unary math.* functions, mapped to IR_FPMATH opcode. */
528 static void LJ_FASTCALL
recff_math_unary(jit_State
*J
, RecordFFData
*rd
)
530 J
->base
[0] = emitir(IRTN(IR_FPMATH
), lj_ir_tonum(J
, J
->base
[0]), rd
->data
);
533 /* Record math.log. */
534 static void LJ_FASTCALL
recff_math_log(jit_State
*J
, RecordFFData
*rd
)
536 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
538 #ifdef LUAJIT_NO_LOG2
539 uint32_t fpm
= IRFPM_LOG
;
541 uint32_t fpm
= IRFPM_LOG2
;
543 TRef trb
= lj_ir_tonum(J
, J
->base
[1]);
544 tr
= emitir(IRTN(IR_FPMATH
), tr
, fpm
);
545 trb
= emitir(IRTN(IR_FPMATH
), trb
, fpm
);
546 trb
= emitir(IRTN(IR_DIV
), lj_ir_knum_one(J
), trb
);
547 tr
= emitir(IRTN(IR_MUL
), tr
, trb
);
549 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_LOG
);
555 /* Record math.atan2. */
556 static void LJ_FASTCALL
recff_math_atan2(jit_State
*J
, RecordFFData
*rd
)
558 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
559 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
560 J
->base
[0] = emitir(IRTN(IR_ATAN2
), tr
, tr2
);
564 /* Record math.ldexp. */
565 static void LJ_FASTCALL
recff_math_ldexp(jit_State
*J
, RecordFFData
*rd
)
567 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
568 #if LJ_TARGET_X86ORX64
569 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
571 TRef tr2
= lj_opt_narrow_toint(J
, J
->base
[1]);
573 J
->base
[0] = emitir(IRTN(IR_LDEXP
), tr
, tr2
);
577 /* Record math.asin, math.acos, math.atan. */
578 static void LJ_FASTCALL
recff_math_atrig(jit_State
*J
, RecordFFData
*rd
)
580 TRef y
= lj_ir_tonum(J
, J
->base
[0]);
581 TRef x
= lj_ir_knum_one(J
);
582 uint32_t ffid
= rd
->data
;
583 if (ffid
!= FF_math_atan
) {
584 TRef tmp
= emitir(IRTN(IR_MUL
), y
, y
);
585 tmp
= emitir(IRTN(IR_SUB
), x
, tmp
);
586 tmp
= emitir(IRTN(IR_FPMATH
), tmp
, IRFPM_SQRT
);
587 if (ffid
== FF_math_asin
) { x
= tmp
; } else { x
= y
; y
= tmp
; }
589 J
->base
[0] = emitir(IRTN(IR_ATAN2
), y
, x
);
592 static void LJ_FASTCALL
recff_math_htrig(jit_State
*J
, RecordFFData
*rd
)
594 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
595 J
->base
[0] = emitir(IRTN(IR_CALLN
), tr
, rd
->data
);
598 static void LJ_FASTCALL
recff_math_modf(jit_State
*J
, RecordFFData
*rd
)
600 TRef tr
= J
->base
[0];
601 if (tref_isinteger(tr
)) {
603 J
->base
[1] = lj_ir_kint(J
, 0);
606 tr
= lj_ir_tonum(J
, tr
);
607 trt
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_TRUNC
);
609 J
->base
[1] = emitir(IRTN(IR_SUB
), tr
, trt
);
614 static void LJ_FASTCALL
recff_math_pow(jit_State
*J
, RecordFFData
*rd
)
616 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
617 if (!tref_isnumber_str(J
->base
[1]))
618 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
619 J
->base
[0] = lj_opt_narrow_pow(J
, tr
, J
->base
[1], &rd
->argv
[1]);
623 static void LJ_FASTCALL
recff_math_minmax(jit_State
*J
, RecordFFData
*rd
)
625 TRef tr
= lj_ir_tonumber(J
, J
->base
[0]);
626 uint32_t op
= rd
->data
;
628 for (i
= 1; J
->base
[i
] != 0; i
++) {
629 TRef tr2
= lj_ir_tonumber(J
, J
->base
[i
]);
631 if (!(tref_isinteger(tr
) && tref_isinteger(tr2
))) {
632 if (tref_isinteger(tr
)) tr
= emitir(IRTN(IR_CONV
), tr
, IRCONV_NUM_INT
);
633 if (tref_isinteger(tr2
)) tr2
= emitir(IRTN(IR_CONV
), tr2
, IRCONV_NUM_INT
);
636 tr
= emitir(IRT(op
, t
), tr
, tr2
);
641 static void LJ_FASTCALL
recff_math_random(jit_State
*J
, RecordFFData
*rd
)
643 GCudata
*ud
= udataV(&J
->fn
->c
.upvalue
[0]);
645 lj_ir_kgc(J
, obj2gco(ud
), IRT_UDATA
); /* Prevent collection. */
646 tr
= lj_ir_call(J
, IRCALL_lj_math_random_step
, lj_ir_kptr(J
, uddata(ud
)));
647 one
= lj_ir_knum_one(J
);
648 tr
= emitir(IRTN(IR_SUB
), tr
, one
);
650 TRef tr1
= lj_ir_tonum(J
, J
->base
[0]);
651 if (J
->base
[1]) { /* d = floor(d*(r2-r1+1.0)) + r1 */
652 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
653 tr2
= emitir(IRTN(IR_SUB
), tr2
, tr1
);
654 tr2
= emitir(IRTN(IR_ADD
), tr2
, one
);
655 tr
= emitir(IRTN(IR_MUL
), tr
, tr2
);
656 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_FLOOR
);
657 tr
= emitir(IRTN(IR_ADD
), tr
, tr1
);
658 } else { /* d = floor(d*r1) + 1.0 */
659 tr
= emitir(IRTN(IR_MUL
), tr
, tr1
);
660 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_FLOOR
);
661 tr
= emitir(IRTN(IR_ADD
), tr
, one
);
668 /* -- Bit library fast functions ------------------------------------------ */
670 /* Record bit.tobit. */
671 static void LJ_FASTCALL
recff_bit_tobit(jit_State
*J
, RecordFFData
*rd
)
673 TRef tr
= J
->base
[0];
675 if (tref_iscdata(tr
)) { recff_bit64_tobit(J
, rd
); return; }
677 J
->base
[0] = lj_opt_narrow_tobit(J
, tr
);
681 /* Record unary bit.bnot, bit.bswap. */
682 static void LJ_FASTCALL
recff_bit_unary(jit_State
*J
, RecordFFData
*rd
)
685 if (recff_bit64_unary(J
, rd
))
688 J
->base
[0] = emitir(IRTI(rd
->data
), lj_opt_narrow_tobit(J
, J
->base
[0]), 0);
691 /* Record N-ary bit.band, bit.bor, bit.bxor. */
692 static void LJ_FASTCALL
recff_bit_nary(jit_State
*J
, RecordFFData
*rd
)
695 if (recff_bit64_nary(J
, rd
))
699 TRef tr
= lj_opt_narrow_tobit(J
, J
->base
[0]);
700 uint32_t ot
= IRTI(rd
->data
);
702 for (i
= 1; J
->base
[i
] != 0; i
++)
703 tr
= emitir(ot
, tr
, lj_opt_narrow_tobit(J
, J
->base
[i
]));
708 /* Record bit shifts. */
709 static void LJ_FASTCALL
recff_bit_shift(jit_State
*J
, RecordFFData
*rd
)
712 if (recff_bit64_shift(J
, rd
))
716 TRef tr
= lj_opt_narrow_tobit(J
, J
->base
[0]);
717 TRef tsh
= lj_opt_narrow_tobit(J
, J
->base
[1]);
718 IROp op
= (IROp
)rd
->data
;
719 if (!(op
< IR_BROL
? LJ_TARGET_MASKSHIFT
: LJ_TARGET_MASKROT
) &&
721 tsh
= emitir(IRTI(IR_BAND
), tsh
, lj_ir_kint(J
, 31));
722 #ifdef LJ_TARGET_UNIFYROT
723 if (op
== (LJ_TARGET_UNIFYROT
== 1 ? IR_BROR
: IR_BROL
)) {
724 op
= LJ_TARGET_UNIFYROT
== 1 ? IR_BROL
: IR_BROR
;
725 tsh
= emitir(IRTI(IR_NEG
), tsh
, tsh
);
728 J
->base
[0] = emitir(IRTI(op
), tr
, tsh
);
732 static void LJ_FASTCALL
recff_bit_tohex(jit_State
*J
, RecordFFData
*rd
)
735 TRef hdr
= recff_bufhdr(J
);
736 TRef tr
= recff_bit64_tohex(J
, rd
, hdr
);
737 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
739 recff_nyiu(J
, rd
); /* Don't bother working around this NYI. */
743 /* -- String library fast functions --------------------------------------- */
745 /* Specialize to relative starting position for string. */
746 static TRef
recff_string_start(jit_State
*J
, GCstr
*s
, int32_t *st
, TRef tr
,
747 TRef trlen
, TRef tr0
)
751 emitir(IRTGI(IR_LT
), tr
, tr0
);
752 tr
= emitir(IRTI(IR_ADD
), trlen
, tr
);
753 start
= start
+ (int32_t)s
->len
;
754 emitir(start
< 0 ? IRTGI(IR_LT
) : IRTGI(IR_GE
), tr
, tr0
);
759 } else if (start
== 0) {
760 emitir(IRTGI(IR_EQ
), tr
, tr0
);
763 tr
= emitir(IRTI(IR_ADD
), tr
, lj_ir_kint(J
, -1));
764 emitir(IRTGI(IR_GE
), tr
, tr0
);
771 /* Handle string.byte (rd->data = 0) and string.sub (rd->data = 1). */
772 static void LJ_FASTCALL
recff_string_range(jit_State
*J
, RecordFFData
*rd
)
774 TRef trstr
= lj_ir_tostr(J
, J
->base
[0]);
775 TRef trlen
= emitir(IRTI(IR_FLOAD
), trstr
, IRFL_STR_LEN
);
776 TRef tr0
= lj_ir_kint(J
, 0);
778 GCstr
*str
= argv2str(J
, &rd
->argv
[0]);
780 if (rd
->data
) { /* string.sub(str, start [,end]) */
781 start
= argv2int(J
, &rd
->argv
[1]);
782 trstart
= lj_opt_narrow_toint(J
, J
->base
[1]);
784 if (tref_isnil(trend
)) {
785 trend
= lj_ir_kint(J
, -1);
788 trend
= lj_opt_narrow_toint(J
, trend
);
789 end
= argv2int(J
, &rd
->argv
[2]);
791 } else { /* string.byte(str, [,start [,end]]) */
792 if (tref_isnil(J
->base
[1])) {
794 trstart
= lj_ir_kint(J
, 1);
796 start
= argv2int(J
, &rd
->argv
[1]);
797 trstart
= lj_opt_narrow_toint(J
, J
->base
[1]);
799 if (J
->base
[1] && !tref_isnil(J
->base
[2])) {
800 trend
= lj_opt_narrow_toint(J
, J
->base
[2]);
801 end
= argv2int(J
, &rd
->argv
[2]);
808 emitir(IRTGI(IR_LT
), trend
, tr0
);
809 trend
= emitir(IRTI(IR_ADD
), emitir(IRTI(IR_ADD
), trlen
, trend
),
811 end
= end
+(int32_t)str
->len
+1;
812 } else if ((MSize
)end
<= str
->len
) {
813 emitir(IRTGI(IR_ULE
), trend
, trlen
);
815 emitir(IRTGI(IR_UGT
), trend
, trlen
);
816 end
= (int32_t)str
->len
;
819 trstart
= recff_string_start(J
, str
, &start
, trstart
, trlen
, tr0
);
820 if (rd
->data
) { /* Return string.sub result. */
821 if (end
- start
>= 0) {
822 /* Also handle empty range here, to avoid extra traces. */
823 TRef trptr
, trslen
= emitir(IRTI(IR_SUB
), trend
, trstart
);
824 emitir(IRTGI(IR_GE
), trslen
, tr0
);
825 trptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, trstart
);
826 J
->base
[0] = emitir(IRT(IR_SNEW
, IRT_STR
), trptr
, trslen
);
827 } else { /* Range underflow: return empty string. */
828 emitir(IRTGI(IR_LT
), trend
, trstart
);
829 J
->base
[0] = lj_ir_kstr(J
, &J2G(J
)->strempty
);
831 } else { /* Return string.byte result(s). */
832 ptrdiff_t i
, len
= end
- start
;
834 TRef trslen
= emitir(IRTI(IR_SUB
), trend
, trstart
);
835 emitir(IRTGI(IR_EQ
), trslen
, lj_ir_kint(J
, (int32_t)len
));
836 if (J
->baseslot
+ len
> LJ_MAX_JSLOTS
)
837 lj_trace_err_info(J
, LJ_TRERR_STACKOV
);
839 for (i
= 0; i
< len
; i
++) {
840 TRef tmp
= emitir(IRTI(IR_ADD
), trstart
, lj_ir_kint(J
, (int32_t)i
));
841 tmp
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, tmp
);
842 J
->base
[i
] = emitir(IRT(IR_XLOAD
, IRT_U8
), tmp
, IRXLOAD_READONLY
);
844 } else { /* Empty range or range underflow: return no results. */
845 emitir(IRTGI(IR_LE
), trend
, trstart
);
851 static void LJ_FASTCALL
recff_string_char(jit_State
*J
, RecordFFData
*rd
)
853 TRef k255
= lj_ir_kint(J
, 255);
855 for (i
= 0; J
->base
[i
] != 0; i
++) { /* Convert char values to strings. */
856 TRef tr
= lj_opt_narrow_toint(J
, J
->base
[i
]);
857 emitir(IRTGI(IR_ULE
), tr
, k255
);
858 J
->base
[i
] = emitir(IRT(IR_TOSTR
, IRT_STR
), tr
, IRTOSTR_CHAR
);
860 if (i
> 1) { /* Concatenate the strings, if there's more than one. */
861 TRef hdr
= recff_bufhdr(J
), tr
= hdr
;
862 for (i
= 0; J
->base
[i
] != 0; i
++)
863 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, J
->base
[i
]);
864 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
869 static void LJ_FASTCALL
recff_string_rep(jit_State
*J
, RecordFFData
*rd
)
871 TRef str
= lj_ir_tostr(J
, J
->base
[0]);
872 TRef rep
= lj_opt_narrow_toint(J
, J
->base
[1]);
873 TRef hdr
, tr
, str2
= 0;
874 if (!tref_isnil(J
->base
[2])) {
875 TRef sep
= lj_ir_tostr(J
, J
->base
[2]);
876 int32_t vrep
= argv2int(J
, &rd
->argv
[1]);
877 emitir(IRTGI(vrep
> 1 ? IR_GT
: IR_LE
), rep
, lj_ir_kint(J
, 1));
879 TRef hdr2
= recff_bufhdr(J
);
880 TRef tr2
= emitir(IRT(IR_BUFPUT
, IRT_P32
), hdr2
, sep
);
881 tr2
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr2
, str
);
882 str2
= emitir(IRT(IR_BUFSTR
, IRT_STR
), tr2
, hdr2
);
885 tr
= hdr
= recff_bufhdr(J
);
887 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, str
);
889 rep
= emitir(IRTI(IR_ADD
), rep
, lj_ir_kint(J
, -1));
891 tr
= lj_ir_call(J
, IRCALL_lj_buf_putstr_rep
, tr
, str
, rep
);
892 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
895 static void LJ_FASTCALL
recff_string_op(jit_State
*J
, RecordFFData
*rd
)
897 TRef str
= lj_ir_tostr(J
, J
->base
[0]);
898 TRef hdr
= recff_bufhdr(J
);
899 TRef tr
= lj_ir_call(J
, rd
->data
, hdr
, str
);
900 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
903 static void LJ_FASTCALL
recff_string_find(jit_State
*J
, RecordFFData
*rd
)
905 TRef trstr
= lj_ir_tostr(J
, J
->base
[0]);
906 TRef trpat
= lj_ir_tostr(J
, J
->base
[1]);
907 TRef trlen
= emitir(IRTI(IR_FLOAD
), trstr
, IRFL_STR_LEN
);
908 TRef tr0
= lj_ir_kint(J
, 0);
910 GCstr
*str
= argv2str(J
, &rd
->argv
[0]);
911 GCstr
*pat
= argv2str(J
, &rd
->argv
[1]);
914 if (tref_isnil(J
->base
[2])) {
915 trstart
= lj_ir_kint(J
, 1);
918 trstart
= lj_opt_narrow_toint(J
, J
->base
[2]);
919 start
= argv2int(J
, &rd
->argv
[2]);
921 trstart
= recff_string_start(J
, str
, &start
, trstart
, trlen
, tr0
);
922 if ((MSize
)start
<= str
->len
) {
923 emitir(IRTGI(IR_ULE
), trstart
, trlen
);
925 emitir(IRTGI(IR_UGT
), trstart
, trlen
);
927 J
->base
[0] = TREF_NIL
;
934 /* Fixed arg or no pattern matching chars? (Specialized to pattern string.) */
935 if ((J
->base
[2] && tref_istruecond(J
->base
[3])) ||
936 (emitir(IRTG(IR_EQ
, IRT_STR
), trpat
, lj_ir_kstr(J
, pat
)),
937 !lj_str_haspattern(pat
))) { /* Search for fixed string. */
938 TRef trsptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, trstart
);
939 TRef trpptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trpat
, tr0
);
940 TRef trslen
= emitir(IRTI(IR_SUB
), trlen
, trstart
);
941 TRef trplen
= emitir(IRTI(IR_FLOAD
), trpat
, IRFL_STR_LEN
);
942 TRef tr
= lj_ir_call(J
, IRCALL_lj_str_find
, trsptr
, trpptr
, trslen
, trplen
);
943 TRef trp0
= lj_ir_kkptr(J
, NULL
);
944 if (lj_str_find(strdata(str
)+(MSize
)start
, strdata(pat
),
945 str
->len
-(MSize
)start
, pat
->len
)) {
947 emitir(IRTG(IR_NE
, IRT_P32
), tr
, trp0
);
948 pos
= emitir(IRTI(IR_SUB
), tr
, emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, tr0
));
949 J
->base
[0] = emitir(IRTI(IR_ADD
), pos
, lj_ir_kint(J
, 1));
950 J
->base
[1] = emitir(IRTI(IR_ADD
), pos
, trplen
);
953 emitir(IRTG(IR_EQ
, IRT_P32
), tr
, trp0
);
954 J
->base
[0] = TREF_NIL
;
956 } else { /* Search for pattern. */
962 static void LJ_FASTCALL
recff_string_format(jit_State
*J
, RecordFFData
*rd
)
964 TRef trfmt
= lj_ir_tostr(J
, J
->base
[0]);
965 GCstr
*fmt
= argv2str(J
, &rd
->argv
[0]);
970 /* Specialize to the format string. */
971 emitir(IRTG(IR_EQ
, IRT_STR
), trfmt
, lj_ir_kstr(J
, fmt
));
972 tr
= hdr
= recff_bufhdr(J
);
973 lj_strfmt_init(&fs
, strdata(fmt
), fmt
->len
);
974 while ((sf
= lj_strfmt_parse(&fs
)) != STRFMT_EOF
) { /* Parse format. */
975 TRef tra
= sf
== STRFMT_LIT
? 0 : J
->base
[arg
++];
976 TRef trsf
= lj_ir_kint(J
, (int32_t)sf
);
978 switch (STRFMT_TYPE(sf
)) {
980 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
981 lj_ir_kstr(J
, lj_str_new(J
->L
, fs
.str
, fs
.len
)));
984 id
= IRCALL_lj_strfmt_putfnum_int
;
986 if (!tref_isinteger(tra
))
988 if (sf
== STRFMT_INT
) { /* Shortcut for plain %d. */
989 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
990 emitir(IRT(IR_TOSTR
, IRT_STR
), tra
, IRTOSTR_INT
));
993 tra
= emitir(IRT(IR_CONV
, IRT_U64
), tra
,
994 (IRT_INT
|(IRT_U64
<<5)|IRCONV_SEXT
));
995 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfxint
, tr
, trsf
, tra
);
998 recff_nyiu(J
, rd
); /* Don't bother working around this NYI. */
1004 id
= IRCALL_lj_strfmt_putfnum_uint
;
1007 id
= IRCALL_lj_strfmt_putfnum
;
1009 tra
= lj_ir_tonum(J
, tra
);
1010 tr
= lj_ir_call(J
, id
, tr
, trsf
, tra
);
1011 if (LJ_SOFTFP
) lj_needsplit(J
);
1014 if (!tref_isstr(tra
)) {
1015 recff_nyiu(J
, rd
); /* NYI: __tostring and non-string types for %s. */
1018 if (sf
== STRFMT_STR
) /* Shortcut for plain %s. */
1019 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, tra
);
1020 else if ((sf
& STRFMT_T_QUOTED
))
1021 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putquoted
, tr
, tra
);
1023 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfstr
, tr
, trsf
, tra
);
1026 tra
= lj_opt_narrow_toint(J
, tra
);
1027 if (sf
== STRFMT_CHAR
) /* Shortcut for plain %c. */
1028 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
1029 emitir(IRT(IR_TOSTR
, IRT_STR
), tra
, IRTOSTR_CHAR
));
1031 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfchar
, tr
, trsf
, tra
);
1033 case STRFMT_PTR
: /* NYI */
1040 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
1043 /* -- Table library fast functions ---------------------------------------- */
1045 static void LJ_FASTCALL
recff_table_insert(jit_State
*J
, RecordFFData
*rd
)
1048 ix
.tab
= J
->base
[0];
1049 ix
.val
= J
->base
[1];
1051 if (tref_istab(ix
.tab
) && ix
.val
) {
1052 if (!J
->base
[2]) { /* Simple push: t[#t+1] = v */
1053 TRef trlen
= lj_ir_call(J
, IRCALL_lj_tab_len
, ix
.tab
);
1054 GCtab
*t
= tabV(&rd
->argv
[0]);
1055 ix
.key
= emitir(IRTI(IR_ADD
), trlen
, lj_ir_kint(J
, 1));
1056 settabV(J
->L
, &ix
.tabv
, t
);
1057 setintV(&ix
.keyv
, lj_tab_len(t
) + 1);
1059 lj_record_idx(J
, &ix
); /* Set new value. */
1060 } else { /* Complex case: insert in the middle. */
1064 } /* else: Interpreter will throw. */
1067 static void LJ_FASTCALL
recff_table_concat(jit_State
*J
, RecordFFData
*rd
)
1069 TRef tab
= J
->base
[0];
1070 if (tref_istab(tab
)) {
1071 TRef sep
= !tref_isnil(J
->base
[1]) ?
1072 lj_ir_tostr(J
, J
->base
[1]) : lj_ir_knull(J
, IRT_STR
);
1073 TRef tri
= (J
->base
[1] && !tref_isnil(J
->base
[2])) ?
1074 lj_opt_narrow_toint(J
, J
->base
[2]) : lj_ir_kint(J
, 1);
1075 TRef tre
= (J
->base
[1] && J
->base
[2] && !tref_isnil(J
->base
[3])) ?
1076 lj_opt_narrow_toint(J
, J
->base
[3]) :
1077 lj_ir_call(J
, IRCALL_lj_tab_len
, tab
);
1078 TRef hdr
= recff_bufhdr(J
);
1079 TRef tr
= lj_ir_call(J
, IRCALL_lj_buf_puttab
, hdr
, tab
, sep
, tri
, tre
);
1080 emitir(IRTG(IR_NE
, IRT_PTR
), tr
, lj_ir_kptr(J
, NULL
));
1081 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
1082 } /* else: Interpreter will throw. */
1086 static void LJ_FASTCALL
recff_table_new(jit_State
*J
, RecordFFData
*rd
)
1088 TRef tra
= lj_opt_narrow_toint(J
, J
->base
[0]);
1089 TRef trh
= lj_opt_narrow_toint(J
, J
->base
[1]);
1090 J
->base
[0] = lj_ir_call(J
, IRCALL_lj_tab_new_ah
, tra
, trh
);
1094 static void LJ_FASTCALL
recff_table_clear(jit_State
*J
, RecordFFData
*rd
)
1096 TRef tr
= J
->base
[0];
1097 if (tref_istab(tr
)) {
1099 lj_ir_call(J
, IRCALL_lj_tab_clear
, tr
);
1101 } /* else: Interpreter will throw. */
1104 /* -- I/O library fast functions ------------------------------------------ */
1106 /* Get FILE* for I/O function. Any I/O error aborts recording, so there's
1107 ** no need to encode the alternate cases for any of the guards.
1109 static TRef
recff_io_fp(jit_State
*J
, TRef
*udp
, int32_t id
)
1112 if (id
) { /* io.func() */
1113 tr
= lj_ir_kptr(J
, &J2G(J
)->gcroot
[id
]);
1114 ud
= emitir(IRT(IR_XLOAD
, IRT_UDATA
), tr
, 0);
1115 } else { /* fp:method() */
1117 if (!tref_isudata(ud
))
1118 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
1119 tr
= emitir(IRT(IR_FLOAD
, IRT_U8
), ud
, IRFL_UDATA_UDTYPE
);
1120 emitir(IRTGI(IR_EQ
), tr
, lj_ir_kint(J
, UDTYPE_IO_FILE
));
1123 fp
= emitir(IRT(IR_FLOAD
, IRT_PTR
), ud
, IRFL_UDATA_FILE
);
1124 emitir(IRTG(IR_NE
, IRT_PTR
), fp
, lj_ir_knull(J
, IRT_PTR
));
1128 static void LJ_FASTCALL
recff_io_write(jit_State
*J
, RecordFFData
*rd
)
1130 TRef ud
, fp
= recff_io_fp(J
, &ud
, rd
->data
);
1131 TRef zero
= lj_ir_kint(J
, 0);
1132 TRef one
= lj_ir_kint(J
, 1);
1133 ptrdiff_t i
= rd
->data
== 0 ? 1 : 0;
1134 for (; J
->base
[i
]; i
++) {
1135 TRef str
= lj_ir_tostr(J
, J
->base
[i
]);
1136 TRef buf
= emitir(IRT(IR_STRREF
, IRT_P32
), str
, zero
);
1137 TRef len
= emitir(IRTI(IR_FLOAD
), str
, IRFL_STR_LEN
);
1138 if (tref_isk(len
) && IR(tref_ref(len
))->i
== 1) {
1139 IRIns
*irs
= IR(tref_ref(str
));
1140 TRef tr
= (irs
->o
== IR_TOSTR
&& irs
->op2
== IRTOSTR_CHAR
) ?
1142 emitir(IRT(IR_XLOAD
, IRT_U8
), buf
, IRXLOAD_READONLY
);
1143 tr
= lj_ir_call(J
, IRCALL_fputc
, tr
, fp
);
1144 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1145 emitir(IRTGI(IR_NE
), tr
, lj_ir_kint(J
, -1));
1147 TRef tr
= lj_ir_call(J
, IRCALL_fwrite
, buf
, one
, len
, fp
);
1148 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1149 emitir(IRTGI(IR_EQ
), tr
, len
);
1152 J
->base
[0] = LJ_52
? ud
: TREF_TRUE
;
1155 static void LJ_FASTCALL
recff_io_flush(jit_State
*J
, RecordFFData
*rd
)
1157 TRef ud
, fp
= recff_io_fp(J
, &ud
, rd
->data
);
1158 TRef tr
= lj_ir_call(J
, IRCALL_fflush
, fp
);
1159 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1160 emitir(IRTGI(IR_EQ
), tr
, lj_ir_kint(J
, 0));
1161 J
->base
[0] = TREF_TRUE
;
1164 /* -- Debug library fast functions ---------------------------------------- */
1166 static void LJ_FASTCALL
recff_debug_getmetatable(jit_State
*J
, RecordFFData
*rd
)
1170 TRef tr
= J
->base
[0];
1171 if (tref_istab(tr
)) {
1172 mt
= tabref(tabV(&rd
->argv
[0])->metatable
);
1173 mtref
= emitir(IRT(IR_FLOAD
, IRT_TAB
), tr
, IRFL_TAB_META
);
1174 } else if (tref_isudata(tr
)) {
1175 mt
= tabref(udataV(&rd
->argv
[0])->metatable
);
1176 mtref
= emitir(IRT(IR_FLOAD
, IRT_TAB
), tr
, IRFL_UDATA_META
);
1178 mt
= tabref(basemt_obj(J2G(J
), &rd
->argv
[0]));
1179 J
->base
[0] = mt
? lj_ir_ktab(J
, mt
) : TREF_NIL
;
1182 emitir(IRTG(mt
? IR_NE
: IR_EQ
, IRT_TAB
), mtref
, lj_ir_knull(J
, IRT_TAB
));
1183 J
->base
[0] = mt
? mtref
: TREF_NIL
;
1186 /* -- Record calls to fast functions -------------------------------------- */
1188 #include "lj_recdef.h"
1190 static uint32_t recdef_lookup(GCfunc
*fn
)
1192 if (fn
->c
.ffid
< sizeof(recff_idmap
)/sizeof(recff_idmap
[0]))
1193 return recff_idmap
[fn
->c
.ffid
];
1198 /* Record entry to a fast function or C function. */
1199 void lj_ffrecord_func(jit_State
*J
)
1202 uint32_t m
= recdef_lookup(J
->fn
);
1204 rd
.nres
= 1; /* Default is one result. */
1205 rd
.argv
= J
->L
->base
;
1206 J
->base
[J
->maxslot
] = 0; /* Mark end of arguments. */
1207 (recff_func
[m
>> 8])(J
, &rd
); /* Call recff_* handler. */
1209 if (J
->postproc
== LJ_POST_NONE
) J
->postproc
= LJ_POST_FFRETRY
;
1210 lj_record_ret(J
, 0, rd
.nres
);