2 ** Fast function call recorder.
3 ** Copyright (C) 2005-2015 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 #ifdef LUAJIT_TRACE_STITCHING
100 /* This feature is disabled for now due to a design mistake. Sorry.
102 ** It causes unpredictable behavior and crashes when a full trace flush
103 ** happens with a stitching continuation still in the stack somewhere.
106 /* Trace stitching: add continuation below frame to start a new trace. */
107 static void recff_stitch(jit_State
*J
)
109 ASMFunction cont
= lj_cont_stitch
;
110 TraceNo traceno
= J
->cur
.traceno
;
112 TValue
*base
= L
->base
;
113 const BCIns
*pc
= frame_pc(base
-1);
114 TValue
*pframe
= frame_prevl(base
-1);
117 lua_assert(!LJ_FR2
); /* TODO_FR2: handle frame shift. */
118 /* Move func + args up in Lua stack and insert continuation. */
119 memmove(&base
[1], &base
[-1], sizeof(TValue
)*(J
->maxslot
+1));
120 setframe_ftsz(base
+1, ((char *)(base
+1) - (char *)pframe
) + FRAME_CONT
);
122 setframe_pc(base
, pc
);
123 if (LJ_DUALNUM
) setintV(base
-1, traceno
); else base
[-1].u64
= traceno
;
127 /* Ditto for the IR. */
128 memmove(&J
->base
[1], &J
->base
[-1], sizeof(TRef
)*(J
->maxslot
+1));
130 trcont
= lj_ir_kptr(J
, (void *)((int64_t)cont
-(int64_t)lj_vm_asm_begin
));
132 trcont
= lj_ir_kptr(J
, (void *)cont
);
134 J
->base
[0] = trcont
| TREF_CONT
;
135 J
->base
[-1] = LJ_DUALNUM
? lj_ir_kint(J
,traceno
) : lj_ir_knum_u64(J
,traceno
);
140 lj_record_stop(J
, LJ_TRLINK_STITCH
, 0);
142 /* Undo Lua stack changes. */
143 memmove(&base
[-1], &base
[1], sizeof(TValue
)*(J
->maxslot
+1));
144 setframe_pc(base
-1, pc
);
149 /* Fallback handler for fast functions that are not recorded (yet). */
150 static void LJ_FASTCALL
recff_nyi(jit_State
*J
, RecordFFData
*rd
)
152 if (J
->cur
.nins
< (IRRef
)J
->param
[JIT_P_minstitch
] + REF_BASE
) {
153 lj_trace_err_info(J
, LJ_TRERR_TRACEUV
);
155 /* Can only stitch from Lua call. */
156 if (J
->framedepth
&& frame_islua(J
->L
->base
-1)) {
157 BCOp op
= bc_op(*frame_pc(J
->L
->base
-1));
158 /* Stitched trace cannot start with *M op with variable # of args. */
159 if (!(op
== BC_CALLM
|| op
== BC_CALLMT
||
160 op
== BC_RETM
|| op
== BC_TSETM
)) {
161 switch (J
->fn
->c
.ffid
) {
163 case FF_debug_sethook
:
165 break; /* Don't stitch across special builtins. */
167 recff_stitch(J
); /* Use trace stitching. */
173 /* Otherwise stop trace and return to interpreter. */
174 lj_record_stop(J
, LJ_TRLINK_RETURN
, 0);
179 /* Fallback handler for unsupported variants of fast functions. */
180 #define recff_nyiu recff_nyi
182 /* Must stop the trace for classic C functions with arbitrary side-effects. */
183 #define recff_c recff_nyi
185 /* Fallback handler for fast functions that are not recorded (yet). */
186 static void LJ_FASTCALL
recff_nyi(jit_State
*J
, RecordFFData
*rd
)
188 setfuncV(J
->L
, &J
->errinfo
, J
->fn
);
189 lj_trace_err_info(J
, LJ_TRERR_NYIFF
);
193 /* Throw error for unsupported variant of fast function. */
194 LJ_NORET
static void recff_nyiu(jit_State
*J
, RecordFFData
*rd
)
196 setfuncV(J
->L
, &J
->errinfo
, J
->fn
);
197 lj_trace_err_info(J
, LJ_TRERR_NYIFFU
);
201 /* Must abort the trace for classic C functions with arbitrary side-effects. */
202 static void LJ_FASTCALL
recff_c(jit_State
*J
, RecordFFData
*rd
)
204 setfuncV(J
->L
, &J
->errinfo
, J
->fn
);
205 lj_trace_err_info(J
, LJ_TRERR_NYICF
);
210 /* Emit BUFHDR for the global temporary buffer. */
211 static TRef
recff_bufhdr(jit_State
*J
)
213 return emitir(IRT(IR_BUFHDR
, IRT_P32
),
214 lj_ir_kptr(J
, &J2G(J
)->tmpbuf
), IRBUFHDR_RESET
);
217 /* -- Base library fast functions ----------------------------------------- */
219 static void LJ_FASTCALL
recff_assert(jit_State
*J
, RecordFFData
*rd
)
221 /* Arguments already specialized. The interpreter throws for nil/false. */
222 rd
->nres
= J
->maxslot
; /* Pass through all arguments. */
225 static void LJ_FASTCALL
recff_type(jit_State
*J
, RecordFFData
*rd
)
227 /* Arguments already specialized. Result is a constant string. Neat, huh? */
229 if (tvisnumber(&rd
->argv
[0]))
231 else if (LJ_64
&& !LJ_GC64
&& tvislightud(&rd
->argv
[0]))
234 t
= ~itype(&rd
->argv
[0]);
235 J
->base
[0] = lj_ir_kstr(J
, strV(&J
->fn
->c
.upvalue
[t
]));
239 static void LJ_FASTCALL
recff_getmetatable(jit_State
*J
, RecordFFData
*rd
)
241 TRef tr
= J
->base
[0];
245 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
246 if (lj_record_mm_lookup(J
, &ix
, MM_metatable
))
247 J
->base
[0] = ix
.mobj
;
250 } /* else: Interpreter will throw. */
253 static void LJ_FASTCALL
recff_setmetatable(jit_State
*J
, RecordFFData
*rd
)
255 TRef tr
= J
->base
[0];
256 TRef mt
= J
->base
[1];
257 if (tref_istab(tr
) && (tref_istab(mt
) || (mt
&& tref_isnil(mt
)))) {
261 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
262 lj_record_mm_lookup(J
, &ix
, MM_metatable
); /* Guard for no __metatable. */
263 fref
= emitir(IRT(IR_FREF
, IRT_P32
), tr
, IRFL_TAB_META
);
264 mtref
= tref_isnil(mt
) ? lj_ir_knull(J
, IRT_TAB
) : mt
;
265 emitir(IRT(IR_FSTORE
, IRT_TAB
), fref
, mtref
);
267 emitir(IRT(IR_TBAR
, IRT_TAB
), tr
, 0);
270 } /* else: Interpreter will throw. */
273 static void LJ_FASTCALL
recff_rawget(jit_State
*J
, RecordFFData
*rd
)
276 ix
.tab
= J
->base
[0]; ix
.key
= J
->base
[1];
277 if (tref_istab(ix
.tab
) && ix
.key
) {
278 ix
.val
= 0; ix
.idxchain
= 0;
279 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
280 copyTV(J
->L
, &ix
.keyv
, &rd
->argv
[1]);
281 J
->base
[0] = lj_record_idx(J
, &ix
);
282 } /* else: Interpreter will throw. */
285 static void LJ_FASTCALL
recff_rawset(jit_State
*J
, RecordFFData
*rd
)
288 ix
.tab
= J
->base
[0]; ix
.key
= J
->base
[1]; ix
.val
= J
->base
[2];
289 if (tref_istab(ix
.tab
) && ix
.key
&& ix
.val
) {
291 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
292 copyTV(J
->L
, &ix
.keyv
, &rd
->argv
[1]);
293 copyTV(J
->L
, &ix
.valv
, &rd
->argv
[2]);
294 lj_record_idx(J
, &ix
);
295 /* Pass through table at J->base[0] as result. */
296 } /* else: Interpreter will throw. */
299 static void LJ_FASTCALL
recff_rawequal(jit_State
*J
, RecordFFData
*rd
)
301 TRef tra
= J
->base
[0];
302 TRef trb
= J
->base
[1];
304 int diff
= lj_record_objcmp(J
, tra
, trb
, &rd
->argv
[0], &rd
->argv
[1]);
305 J
->base
[0] = diff
? TREF_FALSE
: TREF_TRUE
;
306 } /* else: Interpreter will throw. */
310 static void LJ_FASTCALL
recff_rawlen(jit_State
*J
, RecordFFData
*rd
)
312 TRef tr
= J
->base
[0];
314 J
->base
[0] = emitir(IRTI(IR_FLOAD
), tr
, IRFL_STR_LEN
);
315 else if (tref_istab(tr
))
316 J
->base
[0] = lj_ir_call(J
, IRCALL_lj_tab_len
, tr
);
317 /* else: Interpreter will throw. */
322 /* Determine mode of select() call. */
323 int32_t lj_ffrecord_select_mode(jit_State
*J
, TRef tr
, TValue
*tv
)
325 if (tref_isstr(tr
) && *strVdata(tv
) == '#') { /* select('#', ...) */
326 if (strV(tv
)->len
== 1) {
327 emitir(IRTG(IR_EQ
, IRT_STR
), tr
, lj_ir_kstr(J
, strV(tv
)));
329 TRef trptr
= emitir(IRT(IR_STRREF
, IRT_P32
), tr
, lj_ir_kint(J
, 0));
330 TRef trchar
= emitir(IRT(IR_XLOAD
, IRT_U8
), trptr
, IRXLOAD_READONLY
);
331 emitir(IRTG(IR_EQ
, IRT_INT
), trchar
, lj_ir_kint(J
, '#'));
334 } else { /* select(n, ...) */
335 int32_t start
= argv2int(J
, tv
);
336 if (start
== 0) lj_trace_err(J
, LJ_TRERR_BADTYPE
); /* A bit misleading. */
341 static void LJ_FASTCALL
recff_select(jit_State
*J
, RecordFFData
*rd
)
343 TRef tr
= J
->base
[0];
345 ptrdiff_t start
= lj_ffrecord_select_mode(J
, tr
, &rd
->argv
[0]);
346 if (start
== 0) { /* select('#', ...) */
347 J
->base
[0] = lj_ir_kint(J
, J
->maxslot
- 1);
348 } else if (tref_isk(tr
)) { /* select(k, ...) */
349 ptrdiff_t n
= (ptrdiff_t)J
->maxslot
;
350 if (start
< 0) start
+= n
;
351 else if (start
> n
) start
= n
;
352 rd
->nres
= n
- start
;
355 for (i
= 0; i
< n
- start
; i
++)
356 J
->base
[i
] = J
->base
[start
+i
];
357 } /* else: Interpreter will throw. */
362 } /* else: Interpreter will throw. */
365 static void LJ_FASTCALL
recff_tonumber(jit_State
*J
, RecordFFData
*rd
)
367 TRef tr
= J
->base
[0];
368 TRef base
= J
->base
[1];
369 if (tr
&& !tref_isnil(base
)) {
370 base
= lj_opt_narrow_toint(J
, base
);
371 if (!tref_isk(base
) || IR(tref_ref(base
))->i
!= 10) {
376 if (tref_isnumber_str(tr
)) {
377 if (tref_isstr(tr
)) {
379 if (!lj_strscan_num(strV(&rd
->argv
[0]), &tmp
)) {
380 recff_nyiu(J
, rd
); /* Would need an inverted STRTO for this case. */
383 tr
= emitir(IRTG(IR_STRTO
, IRT_NUM
), tr
, 0);
386 } else if (tref_iscdata(tr
)) {
387 lj_crecord_tonumber(J
, rd
);
397 static TValue
*recff_metacall_cp(lua_State
*L
, lua_CFunction dummy
, void *ud
)
399 jit_State
*J
= (jit_State
*)ud
;
400 lj_record_tailcall(J
, 0, 1);
401 UNUSED(L
); UNUSED(dummy
);
405 static int recff_metacall(jit_State
*J
, RecordFFData
*rd
, MMS mm
)
409 copyTV(J
->L
, &ix
.tabv
, &rd
->argv
[0]);
410 if (lj_record_mm_lookup(J
, &ix
, mm
)) { /* Has metamethod? */
413 /* Temporarily insert metamethod below object. */
414 J
->base
[1] = J
->base
[0];
415 J
->base
[0] = ix
.mobj
;
416 copyTV(J
->L
, &argv0
, &rd
->argv
[0]);
417 copyTV(J
->L
, &rd
->argv
[1], &rd
->argv
[0]);
418 copyTV(J
->L
, &rd
->argv
[0], &ix
.mobjv
);
419 /* Need to protect lj_record_tailcall because it may throw. */
420 errcode
= lj_vm_cpcall(J
->L
, NULL
, J
, recff_metacall_cp
);
421 /* Always undo Lua stack changes to avoid confusing the interpreter. */
422 copyTV(J
->L
, &rd
->argv
[0], &argv0
);
424 lj_err_throw(J
->L
, errcode
); /* Propagate errors. */
425 rd
->nres
= -1; /* Pending call. */
426 return 1; /* Tailcalled to metamethod. */
431 static void LJ_FASTCALL
recff_tostring(jit_State
*J
, RecordFFData
*rd
)
433 TRef tr
= J
->base
[0];
434 if (tref_isstr(tr
)) {
435 /* Ignore __tostring in the string base metatable. */
436 /* Pass on result in J->base[0]. */
437 } else if (tr
&& !recff_metacall(J
, rd
, MM_tostring
)) {
438 if (tref_isnumber(tr
)) {
439 J
->base
[0] = emitir(IRT(IR_TOSTR
, IRT_STR
), tr
,
440 tref_isnum(tr
) ? IRTOSTR_NUM
: IRTOSTR_INT
);
441 } else if (tref_ispri(tr
)) {
442 J
->base
[0] = lj_ir_kstr(J
, lj_strfmt_obj(J
->L
, &rd
->argv
[0]));
450 static void LJ_FASTCALL
recff_ipairs_aux(jit_State
*J
, RecordFFData
*rd
)
454 if (tref_istab(ix
.tab
)) {
455 if (!tvisnumber(&rd
->argv
[1])) /* No support for string coercion. */
456 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
457 setintV(&ix
.keyv
, numberVint(&rd
->argv
[1])+1);
458 settabV(J
->L
, &ix
.tabv
, tabV(&rd
->argv
[0]));
459 ix
.val
= 0; ix
.idxchain
= 0;
460 ix
.key
= lj_opt_narrow_toint(J
, J
->base
[1]);
461 J
->base
[0] = ix
.key
= emitir(IRTI(IR_ADD
), ix
.key
, lj_ir_kint(J
, 1));
462 J
->base
[1] = lj_record_idx(J
, &ix
);
463 rd
->nres
= tref_isnil(J
->base
[1]) ? 0 : 2;
464 } /* else: Interpreter will throw. */
467 static void LJ_FASTCALL
recff_xpairs(jit_State
*J
, RecordFFData
*rd
)
469 if (!(LJ_52
&& recff_metacall(J
, rd
, MM_ipairs
))) {
470 TRef tab
= J
->base
[0];
471 if (tref_istab(tab
)) {
472 J
->base
[0] = lj_ir_kfunc(J
, funcV(&J
->fn
->c
.upvalue
[0]));
474 J
->base
[2] = rd
->data
? lj_ir_kint(J
, 0) : TREF_NIL
;
476 } /* else: Interpreter will throw. */
480 static void LJ_FASTCALL
recff_pcall(jit_State
*J
, RecordFFData
*rd
)
482 if (J
->maxslot
>= 1) {
483 lj_record_call(J
, 0, J
->maxslot
- 1);
484 rd
->nres
= -1; /* Pending call. */
485 } /* else: Interpreter will throw. */
488 static TValue
*recff_xpcall_cp(lua_State
*L
, lua_CFunction dummy
, void *ud
)
490 jit_State
*J
= (jit_State
*)ud
;
491 lj_record_call(J
, 1, J
->maxslot
- 2);
492 UNUSED(L
); UNUSED(dummy
);
496 static void LJ_FASTCALL
recff_xpcall(jit_State
*J
, RecordFFData
*rd
)
498 if (J
->maxslot
>= 2) {
502 lua_assert(!LJ_FR2
); /* TODO_FR2: handle different frame setup. */
503 /* Swap function and traceback. */
504 tmp
= J
->base
[0]; J
->base
[0] = J
->base
[1]; J
->base
[1] = tmp
;
505 copyTV(J
->L
, &argv0
, &rd
->argv
[0]);
506 copyTV(J
->L
, &argv1
, &rd
->argv
[1]);
507 copyTV(J
->L
, &rd
->argv
[0], &argv1
);
508 copyTV(J
->L
, &rd
->argv
[1], &argv0
);
509 /* Need to protect lj_record_call because it may throw. */
510 errcode
= lj_vm_cpcall(J
->L
, NULL
, J
, recff_xpcall_cp
);
511 /* Always undo Lua stack swap to avoid confusing the interpreter. */
512 copyTV(J
->L
, &rd
->argv
[0], &argv0
);
513 copyTV(J
->L
, &rd
->argv
[1], &argv1
);
515 lj_err_throw(J
->L
, errcode
); /* Propagate errors. */
516 rd
->nres
= -1; /* Pending call. */
517 } /* else: Interpreter will throw. */
520 static void LJ_FASTCALL
recff_getfenv(jit_State
*J
, RecordFFData
*rd
)
522 TRef tr
= J
->base
[0];
523 /* Only support getfenv(0) for now. */
524 if (tref_isint(tr
) && tref_isk(tr
) && IR(tref_ref(tr
))->i
== 0) {
525 TRef trl
= emitir(IRT(IR_LREF
, IRT_THREAD
), 0, 0);
526 J
->base
[0] = emitir(IRT(IR_FLOAD
, IRT_TAB
), trl
, IRFL_THREAD_ENV
);
532 /* -- Math library fast functions ----------------------------------------- */
534 static void LJ_FASTCALL
recff_math_abs(jit_State
*J
, RecordFFData
*rd
)
536 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
537 J
->base
[0] = emitir(IRTN(IR_ABS
), tr
, lj_ir_knum_abs(J
));
541 /* Record rounding functions math.floor and math.ceil. */
542 static void LJ_FASTCALL
recff_math_round(jit_State
*J
, RecordFFData
*rd
)
544 TRef tr
= J
->base
[0];
545 if (!tref_isinteger(tr
)) { /* Pass through integers unmodified. */
546 tr
= emitir(IRTN(IR_FPMATH
), lj_ir_tonum(J
, tr
), rd
->data
);
547 /* Result is integral (or NaN/Inf), but may not fit an int32_t. */
548 if (LJ_DUALNUM
) { /* Try to narrow using a guarded conversion to int. */
549 lua_Number n
= lj_vm_foldfpm(numberVnum(&rd
->argv
[0]), rd
->data
);
550 if (n
== (lua_Number
)lj_num2int(n
))
551 tr
= emitir(IRTGI(IR_CONV
), tr
, IRCONV_INT_NUM
|IRCONV_CHECK
);
557 /* Record unary math.* functions, mapped to IR_FPMATH opcode. */
558 static void LJ_FASTCALL
recff_math_unary(jit_State
*J
, RecordFFData
*rd
)
560 J
->base
[0] = emitir(IRTN(IR_FPMATH
), lj_ir_tonum(J
, J
->base
[0]), rd
->data
);
563 /* Record math.log. */
564 static void LJ_FASTCALL
recff_math_log(jit_State
*J
, RecordFFData
*rd
)
566 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
568 #ifdef LUAJIT_NO_LOG2
569 uint32_t fpm
= IRFPM_LOG
;
571 uint32_t fpm
= IRFPM_LOG2
;
573 TRef trb
= lj_ir_tonum(J
, J
->base
[1]);
574 tr
= emitir(IRTN(IR_FPMATH
), tr
, fpm
);
575 trb
= emitir(IRTN(IR_FPMATH
), trb
, fpm
);
576 trb
= emitir(IRTN(IR_DIV
), lj_ir_knum_one(J
), trb
);
577 tr
= emitir(IRTN(IR_MUL
), tr
, trb
);
579 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_LOG
);
585 /* Record math.atan2. */
586 static void LJ_FASTCALL
recff_math_atan2(jit_State
*J
, RecordFFData
*rd
)
588 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
589 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
590 J
->base
[0] = emitir(IRTN(IR_ATAN2
), tr
, tr2
);
594 /* Record math.ldexp. */
595 static void LJ_FASTCALL
recff_math_ldexp(jit_State
*J
, RecordFFData
*rd
)
597 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
598 #if LJ_TARGET_X86ORX64
599 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
601 TRef tr2
= lj_opt_narrow_toint(J
, J
->base
[1]);
603 J
->base
[0] = emitir(IRTN(IR_LDEXP
), tr
, tr2
);
607 /* Record math.asin, math.acos, math.atan. */
608 static void LJ_FASTCALL
recff_math_atrig(jit_State
*J
, RecordFFData
*rd
)
610 TRef y
= lj_ir_tonum(J
, J
->base
[0]);
611 TRef x
= lj_ir_knum_one(J
);
612 uint32_t ffid
= rd
->data
;
613 if (ffid
!= FF_math_atan
) {
614 TRef tmp
= emitir(IRTN(IR_MUL
), y
, y
);
615 tmp
= emitir(IRTN(IR_SUB
), x
, tmp
);
616 tmp
= emitir(IRTN(IR_FPMATH
), tmp
, IRFPM_SQRT
);
617 if (ffid
== FF_math_asin
) { x
= tmp
; } else { x
= y
; y
= tmp
; }
619 J
->base
[0] = emitir(IRTN(IR_ATAN2
), y
, x
);
622 static void LJ_FASTCALL
recff_math_htrig(jit_State
*J
, RecordFFData
*rd
)
624 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
625 J
->base
[0] = emitir(IRTN(IR_CALLN
), tr
, rd
->data
);
628 static void LJ_FASTCALL
recff_math_modf(jit_State
*J
, RecordFFData
*rd
)
630 TRef tr
= J
->base
[0];
631 if (tref_isinteger(tr
)) {
633 J
->base
[1] = lj_ir_kint(J
, 0);
636 tr
= lj_ir_tonum(J
, tr
);
637 trt
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_TRUNC
);
639 J
->base
[1] = emitir(IRTN(IR_SUB
), tr
, trt
);
644 static void LJ_FASTCALL
recff_math_pow(jit_State
*J
, RecordFFData
*rd
)
646 TRef tr
= lj_ir_tonum(J
, J
->base
[0]);
647 if (!tref_isnumber_str(J
->base
[1]))
648 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
649 J
->base
[0] = lj_opt_narrow_pow(J
, tr
, J
->base
[1], &rd
->argv
[1]);
653 static void LJ_FASTCALL
recff_math_minmax(jit_State
*J
, RecordFFData
*rd
)
655 TRef tr
= lj_ir_tonumber(J
, J
->base
[0]);
656 uint32_t op
= rd
->data
;
658 for (i
= 1; J
->base
[i
] != 0; i
++) {
659 TRef tr2
= lj_ir_tonumber(J
, J
->base
[i
]);
661 if (!(tref_isinteger(tr
) && tref_isinteger(tr2
))) {
662 if (tref_isinteger(tr
)) tr
= emitir(IRTN(IR_CONV
), tr
, IRCONV_NUM_INT
);
663 if (tref_isinteger(tr2
)) tr2
= emitir(IRTN(IR_CONV
), tr2
, IRCONV_NUM_INT
);
666 tr
= emitir(IRT(op
, t
), tr
, tr2
);
671 static void LJ_FASTCALL
recff_math_random(jit_State
*J
, RecordFFData
*rd
)
673 GCudata
*ud
= udataV(&J
->fn
->c
.upvalue
[0]);
675 lj_ir_kgc(J
, obj2gco(ud
), IRT_UDATA
); /* Prevent collection. */
676 tr
= lj_ir_call(J
, IRCALL_lj_math_random_step
, lj_ir_kptr(J
, uddata(ud
)));
677 one
= lj_ir_knum_one(J
);
678 tr
= emitir(IRTN(IR_SUB
), tr
, one
);
680 TRef tr1
= lj_ir_tonum(J
, J
->base
[0]);
681 if (J
->base
[1]) { /* d = floor(d*(r2-r1+1.0)) + r1 */
682 TRef tr2
= lj_ir_tonum(J
, J
->base
[1]);
683 tr2
= emitir(IRTN(IR_SUB
), tr2
, tr1
);
684 tr2
= emitir(IRTN(IR_ADD
), tr2
, one
);
685 tr
= emitir(IRTN(IR_MUL
), tr
, tr2
);
686 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_FLOOR
);
687 tr
= emitir(IRTN(IR_ADD
), tr
, tr1
);
688 } else { /* d = floor(d*r1) + 1.0 */
689 tr
= emitir(IRTN(IR_MUL
), tr
, tr1
);
690 tr
= emitir(IRTN(IR_FPMATH
), tr
, IRFPM_FLOOR
);
691 tr
= emitir(IRTN(IR_ADD
), tr
, one
);
698 /* -- Bit library fast functions ------------------------------------------ */
700 /* Record bit.tobit. */
701 static void LJ_FASTCALL
recff_bit_tobit(jit_State
*J
, RecordFFData
*rd
)
703 TRef tr
= J
->base
[0];
705 if (tref_iscdata(tr
)) { recff_bit64_tobit(J
, rd
); return; }
707 J
->base
[0] = lj_opt_narrow_tobit(J
, tr
);
711 /* Record unary bit.bnot, bit.bswap. */
712 static void LJ_FASTCALL
recff_bit_unary(jit_State
*J
, RecordFFData
*rd
)
715 if (recff_bit64_unary(J
, rd
))
718 J
->base
[0] = emitir(IRTI(rd
->data
), lj_opt_narrow_tobit(J
, J
->base
[0]), 0);
721 /* Record N-ary bit.band, bit.bor, bit.bxor. */
722 static void LJ_FASTCALL
recff_bit_nary(jit_State
*J
, RecordFFData
*rd
)
725 if (recff_bit64_nary(J
, rd
))
729 TRef tr
= lj_opt_narrow_tobit(J
, J
->base
[0]);
730 uint32_t ot
= IRTI(rd
->data
);
732 for (i
= 1; J
->base
[i
] != 0; i
++)
733 tr
= emitir(ot
, tr
, lj_opt_narrow_tobit(J
, J
->base
[i
]));
738 /* Record bit shifts. */
739 static void LJ_FASTCALL
recff_bit_shift(jit_State
*J
, RecordFFData
*rd
)
742 if (recff_bit64_shift(J
, rd
))
746 TRef tr
= lj_opt_narrow_tobit(J
, J
->base
[0]);
747 TRef tsh
= lj_opt_narrow_tobit(J
, J
->base
[1]);
748 IROp op
= (IROp
)rd
->data
;
749 if (!(op
< IR_BROL
? LJ_TARGET_MASKSHIFT
: LJ_TARGET_MASKROT
) &&
751 tsh
= emitir(IRTI(IR_BAND
), tsh
, lj_ir_kint(J
, 31));
752 #ifdef LJ_TARGET_UNIFYROT
753 if (op
== (LJ_TARGET_UNIFYROT
== 1 ? IR_BROR
: IR_BROL
)) {
754 op
= LJ_TARGET_UNIFYROT
== 1 ? IR_BROL
: IR_BROR
;
755 tsh
= emitir(IRTI(IR_NEG
), tsh
, tsh
);
758 J
->base
[0] = emitir(IRTI(op
), tr
, tsh
);
762 static void LJ_FASTCALL
recff_bit_tohex(jit_State
*J
, RecordFFData
*rd
)
765 TRef hdr
= recff_bufhdr(J
);
766 TRef tr
= recff_bit64_tohex(J
, rd
, hdr
);
767 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
769 recff_nyiu(J
, rd
); /* Don't bother working around this NYI. */
773 /* -- String library fast functions --------------------------------------- */
775 /* Specialize to relative starting position for string. */
776 static TRef
recff_string_start(jit_State
*J
, GCstr
*s
, int32_t *st
, TRef tr
,
777 TRef trlen
, TRef tr0
)
781 emitir(IRTGI(IR_LT
), tr
, tr0
);
782 tr
= emitir(IRTI(IR_ADD
), trlen
, tr
);
783 start
= start
+ (int32_t)s
->len
;
784 emitir(start
< 0 ? IRTGI(IR_LT
) : IRTGI(IR_GE
), tr
, tr0
);
789 } else if (start
== 0) {
790 emitir(IRTGI(IR_EQ
), tr
, tr0
);
793 tr
= emitir(IRTI(IR_ADD
), tr
, lj_ir_kint(J
, -1));
794 emitir(IRTGI(IR_GE
), tr
, tr0
);
801 /* Handle string.byte (rd->data = 0) and string.sub (rd->data = 1). */
802 static void LJ_FASTCALL
recff_string_range(jit_State
*J
, RecordFFData
*rd
)
804 TRef trstr
= lj_ir_tostr(J
, J
->base
[0]);
805 TRef trlen
= emitir(IRTI(IR_FLOAD
), trstr
, IRFL_STR_LEN
);
806 TRef tr0
= lj_ir_kint(J
, 0);
808 GCstr
*str
= argv2str(J
, &rd
->argv
[0]);
810 if (rd
->data
) { /* string.sub(str, start [,end]) */
811 start
= argv2int(J
, &rd
->argv
[1]);
812 trstart
= lj_opt_narrow_toint(J
, J
->base
[1]);
814 if (tref_isnil(trend
)) {
815 trend
= lj_ir_kint(J
, -1);
818 trend
= lj_opt_narrow_toint(J
, trend
);
819 end
= argv2int(J
, &rd
->argv
[2]);
821 } else { /* string.byte(str, [,start [,end]]) */
822 if (tref_isnil(J
->base
[1])) {
824 trstart
= lj_ir_kint(J
, 1);
826 start
= argv2int(J
, &rd
->argv
[1]);
827 trstart
= lj_opt_narrow_toint(J
, J
->base
[1]);
829 if (J
->base
[1] && !tref_isnil(J
->base
[2])) {
830 trend
= lj_opt_narrow_toint(J
, J
->base
[2]);
831 end
= argv2int(J
, &rd
->argv
[2]);
838 emitir(IRTGI(IR_LT
), trend
, tr0
);
839 trend
= emitir(IRTI(IR_ADD
), emitir(IRTI(IR_ADD
), trlen
, trend
),
841 end
= end
+(int32_t)str
->len
+1;
842 } else if ((MSize
)end
<= str
->len
) {
843 emitir(IRTGI(IR_ULE
), trend
, trlen
);
845 emitir(IRTGI(IR_UGT
), trend
, trlen
);
846 end
= (int32_t)str
->len
;
849 trstart
= recff_string_start(J
, str
, &start
, trstart
, trlen
, tr0
);
850 if (rd
->data
) { /* Return string.sub result. */
851 if (end
- start
>= 0) {
852 /* Also handle empty range here, to avoid extra traces. */
853 TRef trptr
, trslen
= emitir(IRTI(IR_SUB
), trend
, trstart
);
854 emitir(IRTGI(IR_GE
), trslen
, tr0
);
855 trptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, trstart
);
856 J
->base
[0] = emitir(IRT(IR_SNEW
, IRT_STR
), trptr
, trslen
);
857 } else { /* Range underflow: return empty string. */
858 emitir(IRTGI(IR_LT
), trend
, trstart
);
859 J
->base
[0] = lj_ir_kstr(J
, &J2G(J
)->strempty
);
861 } else { /* Return string.byte result(s). */
862 ptrdiff_t i
, len
= end
- start
;
864 TRef trslen
= emitir(IRTI(IR_SUB
), trend
, trstart
);
865 emitir(IRTGI(IR_EQ
), trslen
, lj_ir_kint(J
, (int32_t)len
));
866 if (J
->baseslot
+ len
> LJ_MAX_JSLOTS
)
867 lj_trace_err_info(J
, LJ_TRERR_STACKOV
);
869 for (i
= 0; i
< len
; i
++) {
870 TRef tmp
= emitir(IRTI(IR_ADD
), trstart
, lj_ir_kint(J
, (int32_t)i
));
871 tmp
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, tmp
);
872 J
->base
[i
] = emitir(IRT(IR_XLOAD
, IRT_U8
), tmp
, IRXLOAD_READONLY
);
874 } else { /* Empty range or range underflow: return no results. */
875 emitir(IRTGI(IR_LE
), trend
, trstart
);
881 static void LJ_FASTCALL
recff_string_char(jit_State
*J
, RecordFFData
*rd
)
883 TRef k255
= lj_ir_kint(J
, 255);
885 for (i
= 0; J
->base
[i
] != 0; i
++) { /* Convert char values to strings. */
886 TRef tr
= lj_opt_narrow_toint(J
, J
->base
[i
]);
887 emitir(IRTGI(IR_ULE
), tr
, k255
);
888 J
->base
[i
] = emitir(IRT(IR_TOSTR
, IRT_STR
), tr
, IRTOSTR_CHAR
);
890 if (i
> 1) { /* Concatenate the strings, if there's more than one. */
891 TRef hdr
= recff_bufhdr(J
), tr
= hdr
;
892 for (i
= 0; J
->base
[i
] != 0; i
++)
893 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, J
->base
[i
]);
894 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
899 static void LJ_FASTCALL
recff_string_rep(jit_State
*J
, RecordFFData
*rd
)
901 TRef str
= lj_ir_tostr(J
, J
->base
[0]);
902 TRef rep
= lj_opt_narrow_toint(J
, J
->base
[1]);
903 TRef hdr
, tr
, str2
= 0;
904 if (!tref_isnil(J
->base
[2])) {
905 TRef sep
= lj_ir_tostr(J
, J
->base
[2]);
906 int32_t vrep
= argv2int(J
, &rd
->argv
[1]);
907 emitir(IRTGI(vrep
> 1 ? IR_GT
: IR_LE
), rep
, lj_ir_kint(J
, 1));
909 TRef hdr2
= recff_bufhdr(J
);
910 TRef tr2
= emitir(IRT(IR_BUFPUT
, IRT_P32
), hdr2
, sep
);
911 tr2
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr2
, str
);
912 str2
= emitir(IRT(IR_BUFSTR
, IRT_STR
), tr2
, hdr2
);
915 tr
= hdr
= recff_bufhdr(J
);
917 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, str
);
919 rep
= emitir(IRTI(IR_ADD
), rep
, lj_ir_kint(J
, -1));
921 tr
= lj_ir_call(J
, IRCALL_lj_buf_putstr_rep
, tr
, str
, rep
);
922 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
925 static void LJ_FASTCALL
recff_string_op(jit_State
*J
, RecordFFData
*rd
)
927 TRef str
= lj_ir_tostr(J
, J
->base
[0]);
928 TRef hdr
= recff_bufhdr(J
);
929 TRef tr
= lj_ir_call(J
, rd
->data
, hdr
, str
);
930 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
933 static void LJ_FASTCALL
recff_string_find(jit_State
*J
, RecordFFData
*rd
)
935 TRef trstr
= lj_ir_tostr(J
, J
->base
[0]);
936 TRef trpat
= lj_ir_tostr(J
, J
->base
[1]);
937 TRef trlen
= emitir(IRTI(IR_FLOAD
), trstr
, IRFL_STR_LEN
);
938 TRef tr0
= lj_ir_kint(J
, 0);
940 GCstr
*str
= argv2str(J
, &rd
->argv
[0]);
941 GCstr
*pat
= argv2str(J
, &rd
->argv
[1]);
944 if (tref_isnil(J
->base
[2])) {
945 trstart
= lj_ir_kint(J
, 1);
948 trstart
= lj_opt_narrow_toint(J
, J
->base
[2]);
949 start
= argv2int(J
, &rd
->argv
[2]);
951 trstart
= recff_string_start(J
, str
, &start
, trstart
, trlen
, tr0
);
952 if ((MSize
)start
<= str
->len
) {
953 emitir(IRTGI(IR_ULE
), trstart
, trlen
);
955 emitir(IRTGI(IR_UGT
), trstart
, trlen
);
957 J
->base
[0] = TREF_NIL
;
964 /* Fixed arg or no pattern matching chars? (Specialized to pattern string.) */
965 if ((J
->base
[2] && tref_istruecond(J
->base
[3])) ||
966 (emitir(IRTG(IR_EQ
, IRT_STR
), trpat
, lj_ir_kstr(J
, pat
)),
967 !lj_str_haspattern(pat
))) { /* Search for fixed string. */
968 TRef trsptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, trstart
);
969 TRef trpptr
= emitir(IRT(IR_STRREF
, IRT_P32
), trpat
, tr0
);
970 TRef trslen
= emitir(IRTI(IR_SUB
), trlen
, trstart
);
971 TRef trplen
= emitir(IRTI(IR_FLOAD
), trpat
, IRFL_STR_LEN
);
972 TRef tr
= lj_ir_call(J
, IRCALL_lj_str_find
, trsptr
, trpptr
, trslen
, trplen
);
973 TRef trp0
= lj_ir_kkptr(J
, NULL
);
974 if (lj_str_find(strdata(str
)+(MSize
)start
, strdata(pat
),
975 str
->len
-(MSize
)start
, pat
->len
)) {
977 emitir(IRTG(IR_NE
, IRT_P32
), tr
, trp0
);
978 pos
= emitir(IRTI(IR_SUB
), tr
, emitir(IRT(IR_STRREF
, IRT_P32
), trstr
, tr0
));
979 J
->base
[0] = emitir(IRTI(IR_ADD
), pos
, lj_ir_kint(J
, 1));
980 J
->base
[1] = emitir(IRTI(IR_ADD
), pos
, trplen
);
983 emitir(IRTG(IR_EQ
, IRT_P32
), tr
, trp0
);
984 J
->base
[0] = TREF_NIL
;
986 } else { /* Search for pattern. */
992 static void LJ_FASTCALL
recff_string_format(jit_State
*J
, RecordFFData
*rd
)
994 TRef trfmt
= lj_ir_tostr(J
, J
->base
[0]);
995 GCstr
*fmt
= argv2str(J
, &rd
->argv
[0]);
1000 /* Specialize to the format string. */
1001 emitir(IRTG(IR_EQ
, IRT_STR
), trfmt
, lj_ir_kstr(J
, fmt
));
1002 tr
= hdr
= recff_bufhdr(J
);
1003 lj_strfmt_init(&fs
, strdata(fmt
), fmt
->len
);
1004 while ((sf
= lj_strfmt_parse(&fs
)) != STRFMT_EOF
) { /* Parse format. */
1005 TRef tra
= sf
== STRFMT_LIT
? 0 : J
->base
[arg
++];
1006 TRef trsf
= lj_ir_kint(J
, (int32_t)sf
);
1008 switch (STRFMT_TYPE(sf
)) {
1010 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
1011 lj_ir_kstr(J
, lj_str_new(J
->L
, fs
.str
, fs
.len
)));
1014 id
= IRCALL_lj_strfmt_putfnum_int
;
1016 if (!tref_isinteger(tra
))
1018 if (sf
== STRFMT_INT
) { /* Shortcut for plain %d. */
1019 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
1020 emitir(IRT(IR_TOSTR
, IRT_STR
), tra
, IRTOSTR_INT
));
1023 tra
= emitir(IRT(IR_CONV
, IRT_U64
), tra
,
1024 (IRT_INT
|(IRT_U64
<<5)|IRCONV_SEXT
));
1025 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfxint
, tr
, trsf
, tra
);
1028 recff_nyiu(J
, rd
); /* Don't bother working around this NYI. */
1034 id
= IRCALL_lj_strfmt_putfnum_uint
;
1037 id
= IRCALL_lj_strfmt_putfnum
;
1039 tra
= lj_ir_tonum(J
, tra
);
1040 tr
= lj_ir_call(J
, id
, tr
, trsf
, tra
);
1041 if (LJ_SOFTFP
) lj_needsplit(J
);
1044 if (!tref_isstr(tra
)) {
1045 recff_nyiu(J
, rd
); /* NYI: __tostring and non-string types for %s. */
1048 if (sf
== STRFMT_STR
) /* Shortcut for plain %s. */
1049 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
, tra
);
1050 else if ((sf
& STRFMT_T_QUOTED
))
1051 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putquoted
, tr
, tra
);
1053 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfstr
, tr
, trsf
, tra
);
1056 tra
= lj_opt_narrow_toint(J
, tra
);
1057 if (sf
== STRFMT_CHAR
) /* Shortcut for plain %c. */
1058 tr
= emitir(IRT(IR_BUFPUT
, IRT_P32
), tr
,
1059 emitir(IRT(IR_TOSTR
, IRT_STR
), tra
, IRTOSTR_CHAR
));
1061 tr
= lj_ir_call(J
, IRCALL_lj_strfmt_putfchar
, tr
, trsf
, tra
);
1063 case STRFMT_PTR
: /* NYI */
1070 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
1073 /* -- Table library fast functions ---------------------------------------- */
1075 static void LJ_FASTCALL
recff_table_insert(jit_State
*J
, RecordFFData
*rd
)
1078 ix
.tab
= J
->base
[0];
1079 ix
.val
= J
->base
[1];
1081 if (tref_istab(ix
.tab
) && ix
.val
) {
1082 if (!J
->base
[2]) { /* Simple push: t[#t+1] = v */
1083 TRef trlen
= lj_ir_call(J
, IRCALL_lj_tab_len
, ix
.tab
);
1084 GCtab
*t
= tabV(&rd
->argv
[0]);
1085 ix
.key
= emitir(IRTI(IR_ADD
), trlen
, lj_ir_kint(J
, 1));
1086 settabV(J
->L
, &ix
.tabv
, t
);
1087 setintV(&ix
.keyv
, lj_tab_len(t
) + 1);
1089 lj_record_idx(J
, &ix
); /* Set new value. */
1090 } else { /* Complex case: insert in the middle. */
1094 } /* else: Interpreter will throw. */
1097 static void LJ_FASTCALL
recff_table_concat(jit_State
*J
, RecordFFData
*rd
)
1099 TRef tab
= J
->base
[0];
1100 if (tref_istab(tab
)) {
1101 TRef sep
= !tref_isnil(J
->base
[1]) ?
1102 lj_ir_tostr(J
, J
->base
[1]) : lj_ir_knull(J
, IRT_STR
);
1103 TRef tri
= (J
->base
[1] && !tref_isnil(J
->base
[2])) ?
1104 lj_opt_narrow_toint(J
, J
->base
[2]) : lj_ir_kint(J
, 1);
1105 TRef tre
= (J
->base
[1] && J
->base
[2] && !tref_isnil(J
->base
[3])) ?
1106 lj_opt_narrow_toint(J
, J
->base
[3]) :
1107 lj_ir_call(J
, IRCALL_lj_tab_len
, tab
);
1108 TRef hdr
= recff_bufhdr(J
);
1109 TRef tr
= lj_ir_call(J
, IRCALL_lj_buf_puttab
, hdr
, tab
, sep
, tri
, tre
);
1110 emitir(IRTG(IR_NE
, IRT_PTR
), tr
, lj_ir_kptr(J
, NULL
));
1111 J
->base
[0] = emitir(IRT(IR_BUFSTR
, IRT_STR
), tr
, hdr
);
1112 } /* else: Interpreter will throw. */
1116 static void LJ_FASTCALL
recff_table_new(jit_State
*J
, RecordFFData
*rd
)
1118 TRef tra
= lj_opt_narrow_toint(J
, J
->base
[0]);
1119 TRef trh
= lj_opt_narrow_toint(J
, J
->base
[1]);
1120 J
->base
[0] = lj_ir_call(J
, IRCALL_lj_tab_new_ah
, tra
, trh
);
1124 static void LJ_FASTCALL
recff_table_clear(jit_State
*J
, RecordFFData
*rd
)
1126 TRef tr
= J
->base
[0];
1127 if (tref_istab(tr
)) {
1129 lj_ir_call(J
, IRCALL_lj_tab_clear
, tr
);
1131 } /* else: Interpreter will throw. */
1134 /* -- I/O library fast functions ------------------------------------------ */
1136 /* Get FILE* for I/O function. Any I/O error aborts recording, so there's
1137 ** no need to encode the alternate cases for any of the guards.
1139 static TRef
recff_io_fp(jit_State
*J
, TRef
*udp
, int32_t id
)
1142 if (id
) { /* io.func() */
1143 tr
= lj_ir_kptr(J
, &J2G(J
)->gcroot
[id
]);
1144 ud
= emitir(IRT(IR_XLOAD
, IRT_UDATA
), tr
, 0);
1145 } else { /* fp:method() */
1147 if (!tref_isudata(ud
))
1148 lj_trace_err(J
, LJ_TRERR_BADTYPE
);
1149 tr
= emitir(IRT(IR_FLOAD
, IRT_U8
), ud
, IRFL_UDATA_UDTYPE
);
1150 emitir(IRTGI(IR_EQ
), tr
, lj_ir_kint(J
, UDTYPE_IO_FILE
));
1153 fp
= emitir(IRT(IR_FLOAD
, IRT_PTR
), ud
, IRFL_UDATA_FILE
);
1154 emitir(IRTG(IR_NE
, IRT_PTR
), fp
, lj_ir_knull(J
, IRT_PTR
));
1158 static void LJ_FASTCALL
recff_io_write(jit_State
*J
, RecordFFData
*rd
)
1160 TRef ud
, fp
= recff_io_fp(J
, &ud
, rd
->data
);
1161 TRef zero
= lj_ir_kint(J
, 0);
1162 TRef one
= lj_ir_kint(J
, 1);
1163 ptrdiff_t i
= rd
->data
== 0 ? 1 : 0;
1164 for (; J
->base
[i
]; i
++) {
1165 TRef str
= lj_ir_tostr(J
, J
->base
[i
]);
1166 TRef buf
= emitir(IRT(IR_STRREF
, IRT_P32
), str
, zero
);
1167 TRef len
= emitir(IRTI(IR_FLOAD
), str
, IRFL_STR_LEN
);
1168 if (tref_isk(len
) && IR(tref_ref(len
))->i
== 1) {
1169 IRIns
*irs
= IR(tref_ref(str
));
1170 TRef tr
= (irs
->o
== IR_TOSTR
&& irs
->op2
== IRTOSTR_CHAR
) ?
1172 emitir(IRT(IR_XLOAD
, IRT_U8
), buf
, IRXLOAD_READONLY
);
1173 tr
= lj_ir_call(J
, IRCALL_fputc
, tr
, fp
);
1174 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1175 emitir(IRTGI(IR_NE
), tr
, lj_ir_kint(J
, -1));
1177 TRef tr
= lj_ir_call(J
, IRCALL_fwrite
, buf
, one
, len
, fp
);
1178 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1179 emitir(IRTGI(IR_EQ
), tr
, len
);
1182 J
->base
[0] = LJ_52
? ud
: TREF_TRUE
;
1185 static void LJ_FASTCALL
recff_io_flush(jit_State
*J
, RecordFFData
*rd
)
1187 TRef ud
, fp
= recff_io_fp(J
, &ud
, rd
->data
);
1188 TRef tr
= lj_ir_call(J
, IRCALL_fflush
, fp
);
1189 if (results_wanted(J
) != 0) /* Check result only if not ignored. */
1190 emitir(IRTGI(IR_EQ
), tr
, lj_ir_kint(J
, 0));
1191 J
->base
[0] = TREF_TRUE
;
1194 /* -- Debug library fast functions ---------------------------------------- */
1196 static void LJ_FASTCALL
recff_debug_getmetatable(jit_State
*J
, RecordFFData
*rd
)
1200 TRef tr
= J
->base
[0];
1201 if (tref_istab(tr
)) {
1202 mt
= tabref(tabV(&rd
->argv
[0])->metatable
);
1203 mtref
= emitir(IRT(IR_FLOAD
, IRT_TAB
), tr
, IRFL_TAB_META
);
1204 } else if (tref_isudata(tr
)) {
1205 mt
= tabref(udataV(&rd
->argv
[0])->metatable
);
1206 mtref
= emitir(IRT(IR_FLOAD
, IRT_TAB
), tr
, IRFL_UDATA_META
);
1208 mt
= tabref(basemt_obj(J2G(J
), &rd
->argv
[0]));
1209 J
->base
[0] = mt
? lj_ir_ktab(J
, mt
) : TREF_NIL
;
1212 emitir(IRTG(mt
? IR_NE
: IR_EQ
, IRT_TAB
), mtref
, lj_ir_knull(J
, IRT_TAB
));
1213 J
->base
[0] = mt
? mtref
: TREF_NIL
;
1216 /* -- Record calls to fast functions -------------------------------------- */
1218 #include "lj_recdef.h"
1220 static uint32_t recdef_lookup(GCfunc
*fn
)
1222 if (fn
->c
.ffid
< sizeof(recff_idmap
)/sizeof(recff_idmap
[0]))
1223 return recff_idmap
[fn
->c
.ffid
];
1228 /* Record entry to a fast function or C function. */
1229 void lj_ffrecord_func(jit_State
*J
)
1232 uint32_t m
= recdef_lookup(J
->fn
);
1234 rd
.nres
= 1; /* Default is one result. */
1235 rd
.argv
= J
->L
->base
;
1236 J
->base
[J
->maxslot
] = 0; /* Mark end of arguments. */
1237 (recff_func
[m
>> 8])(J
, &rd
); /* Call recff_* handler. */
1239 if (J
->postproc
== LJ_POST_NONE
) J
->postproc
= LJ_POST_FFRETRY
;
1240 lj_record_ret(J
, 0, rd
.nres
);