Mercurial

comparison third_party/luajit/src/vm_ppc.dasc @ 178:94705b5986b3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added WRK and luajit for load testing.
author MrJuneJune <me@mrjunejune.com>
date Thu, 22 Jan 2026 20:10:30 -0800
parents
children
comparison
equal deleted inserted replaced
177:24fe8ff94056 178:94705b5986b3
1 |// Low-level VM code for PowerPC 32 bit or 32on64 bit mode.
2 |// Bytecode interpreter, fast functions and helper functions.
3 |// Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
4 |
5 |.arch ppc
6 |.section code_op, code_sub
7 |
8 |.actionlist build_actionlist
9 |.globals GLOB_
10 |.globalnames globnames
11 |.externnames extnames
12 |
13 |// Note: The ragged indentation of the instructions is intentional.
14 |// The starting columns indicate data dependencies.
15 |
16 |//-----------------------------------------------------------------------
17 |
18 |// DynASM defines used by the PPC port:
19 |//
20 |// P64 64 bit pointers (only for GPR64 testing).
21 |// GPR64 64 bit registers (but possibly 32 bit pointers, e.g. PS3).
22 |// Affects reg saves, stack layout, carry/overflow/dot flags etc.
23 |// FRAME32 Use 32 bit frame layout, even with GPR64 (Xbox 360).
24 |// TOC Need table of contents (64 bit or 32 bit variant, e.g. PS3).
25 |// Function pointers are really a struct: code, TOC, env (optional).
26 |// TOCENV Function pointers have an environment pointer, too (not on PS3).
27 |// PPE Power Processor Element of Cell (PS3) or Xenon (Xbox 360).
28 |// Must avoid (slow) micro-coded instructions.
29 |
30 |.if P64
31 |.define TOC, 1
32 |.define TOCENV, 1
33 |.macro lpx, a, b, c; ldx a, b, c; .endmacro
34 |.macro lp, a, b; ld a, b; .endmacro
35 |.macro stp, a, b; std a, b; .endmacro
36 |.define decode_OPP, decode_OP8
37 |.if FFI
38 |// Missing: Calling conventions, 64 bit regs, TOC.
39 |.error lib_ffi not yet implemented for PPC64
40 |.endif
41 |.else
42 |.macro lpx, a, b, c; lwzx a, b, c; .endmacro
43 |.macro lp, a, b; lwz a, b; .endmacro
44 |.macro stp, a, b; stw a, b; .endmacro
45 |.define decode_OPP, decode_OP4
46 |.endif
47 |
48 |// Convenience macros for TOC handling.
49 |.if TOC
50 |// Linker needs a TOC patch area for every external call relocation.
51 |.macro blex, target; bl extern target@plt; nop; .endmacro
52 |.macro .toc, a, b; a, b; .endmacro
53 |.if P64
54 |.define TOC_OFS, 8
55 |.define ENV_OFS, 16
56 |.else
57 |.define TOC_OFS, 4
58 |.define ENV_OFS, 8
59 |.endif
60 |.else // No TOC.
61 |.macro blex, target; bl extern target@plt; .endmacro
62 |.macro .toc, a, b; .endmacro
63 |.endif
64 |.macro .tocenv, a, b; .if TOCENV; a, b; .endif; .endmacro
65 |
66 |.macro .gpr64, a, b; .if GPR64; a, b; .endif; .endmacro
67 |
68 |.macro andix., y, a, i
69 |.if PPE
70 | rlwinm y, a, 0, 31-lj_fls(i), 31-lj_ffs(i)
71 | cmpwi y, 0
72 |.else
73 | andi. y, a, i
74 |.endif
75 |.endmacro
76 |
77 |.macro clrso, reg
78 |.if PPE
79 | li reg, 0
80 | mtxer reg
81 |.else
82 | mcrxr cr0
83 |.endif
84 |.endmacro
85 |
86 |.macro checkov, reg, noov
87 |.if PPE
88 | mfxer reg
89 | add reg, reg, reg
90 | cmpwi reg, 0
91 | li reg, 0
92 | mtxer reg
93 | bgey noov
94 |.else
95 | mcrxr cr0
96 | bley noov
97 |.endif
98 |.endmacro
99 |
100 |//-----------------------------------------------------------------------
101 |
102 |// Fixed register assignments for the interpreter.
103 |// Don't use: r1 = sp, r2 and r13 = reserved (TOC, TLS or SDATA)
104 |
105 |.macro .FPU, a, b
106 |.if FPU
107 | a, b
108 |.endif
109 |.endmacro
110 |
111 |.macro .FPU, a, b, c
112 |.if FPU
113 | a, b, c
114 |.endif
115 |.endmacro
116 |
117 |// The following must be C callee-save (but BASE is often refetched).
118 |.define BASE, r14 // Base of current Lua stack frame.
119 |.define KBASE, r15 // Constants of current Lua function.
120 |.define PC, r16 // Next PC.
121 |.define DISPATCH, r17 // Opcode dispatch table.
122 |.define LREG, r18 // Register holding lua_State (also in SAVE_L).
123 |.define MULTRES, r19 // Size of multi-result: (nresults+1)*8.
124 |.define JGL, r31 // On-trace: global_State + 32768.
125 |
126 |// Constants for type-comparisons, stores and conversions. C callee-save.
127 |.define TISNUM, r22
128 |.define TISNIL, r23
129 |.define ZERO, r24
130 |.if FPU
131 |.define TOBIT, f30 // 2^52 + 2^51.
132 |.define TONUM, f31 // 2^52 + 2^51 + 2^31.
133 |.endif
134 |
135 |// The following temporaries are not saved across C calls, except for RA.
136 |.define RA, r20 // Callee-save.
137 |.define RB, r10
138 |.define RC, r11
139 |.define RD, r12
140 |.define INS, r7 // Overlaps CARG5.
141 |
142 |.define TMP0, r0
143 |.define TMP1, r8
144 |.define TMP2, r9
145 |.define TMP3, r6 // Overlaps CARG4.
146 |
147 |// Saved temporaries.
148 |.define SAVE0, r21
149 |.define SAVE1, r25
150 |
151 |// Calling conventions.
152 |.define CARG1, r3
153 |.define CARG2, r4
154 |.define CARG3, r5
155 |.define CARG4, r6 // Overlaps TMP3.
156 |.define CARG5, r7 // Overlaps INS.
157 |
158 |.if FPU
159 |.define FARG1, f1
160 |.define FARG2, f2
161 |.endif
162 |
163 |.define CRET1, r3
164 |.define CRET2, r4
165 |
166 |.define TOCREG, r2 // TOC register (only used by C code).
167 |.define ENVREG, r11 // Environment pointer (nested C functions).
168 |
169 |// Stack layout while in interpreter. Must match with lj_frame.h.
170 |.if GPR64
171 |.if FRAME32
172 |
173 |// 456(sp) // \ 32/64 bit C frame info
174 |.define TONUM_LO, 452(sp) // |
175 |.define TONUM_HI, 448(sp) // |
176 |.define TMPD_LO, 444(sp) // |
177 |.define TMPD_HI, 440(sp) // |
178 |.define SAVE_CR, 432(sp) // | 64 bit CR save.
179 |.define SAVE_ERRF, 424(sp) // > Parameter save area.
180 |.define SAVE_NRES, 420(sp) // |
181 |.define SAVE_L, 416(sp) // |
182 |.define SAVE_PC, 412(sp) // |
183 |.define SAVE_MULTRES, 408(sp) // |
184 |.define SAVE_CFRAME, 400(sp) // / 64 bit C frame chain.
185 |// 392(sp) // Reserved.
186 |.define CFRAME_SPACE, 384 // Delta for sp.
187 |// Back chain for sp: 384(sp) <-- sp entering interpreter
188 |.define SAVE_LR, 376(sp) // 32 bit LR stored in hi-part.
189 |.define SAVE_GPR_, 232 // .. 232+18*8: 64 bit GPR saves.
190 |.define SAVE_FPR_, 88 // .. 88+18*8: 64 bit FPR saves.
191 |// 80(sp) // Needed for 16 byte stack frame alignment.
192 |// 16(sp) // Callee parameter save area (ABI mandated).
193 |// 8(sp) // Reserved
194 |// Back chain for sp: 0(sp) <-- sp while in interpreter
195 |// 32 bit sp stored in hi-part of 0(sp).
196 |
197 |.define TMPD_BLO, 447(sp)
198 |.define TMPD, TMPD_HI
199 |.define TONUM_D, TONUM_HI
200 |
201 |.else
202 |
203 |// 508(sp) // \ 32 bit C frame info.
204 |.define SAVE_ERRF, 472(sp) // |
205 |.define SAVE_NRES, 468(sp) // |
206 |.define SAVE_L, 464(sp) // > Parameter save area.
207 |.define SAVE_PC, 460(sp) // |
208 |.define SAVE_MULTRES, 456(sp) // |
209 |.define SAVE_CFRAME, 448(sp) // / 64 bit C frame chain.
210 |.define SAVE_LR, 416(sp)
211 |.define CFRAME_SPACE, 400 // Delta for sp.
212 |// Back chain for sp: 400(sp) <-- sp entering interpreter
213 |.define SAVE_FPR_, 256 // .. 256+18*8: 64 bit FPR saves.
214 |.define SAVE_GPR_, 112 // .. 112+18*8: 64 bit GPR saves.
215 |// 48(sp) // Callee parameter save area (ABI mandated).
216 |.define SAVE_TOC, 40(sp) // TOC save area.
217 |.define TMPD_LO, 36(sp) // \ Link editor temp (ABI mandated).
218 |.define TMPD_HI, 32(sp) // /
219 |.define TONUM_LO, 28(sp) // \ Compiler temp (ABI mandated).
220 |.define TONUM_HI, 24(sp) // /
221 |// Next frame lr: 16(sp)
222 |.define SAVE_CR, 8(sp) // 64 bit CR save.
223 |// Back chain for sp: 0(sp) <-- sp while in interpreter
224 |
225 |.define TMPD_BLO, 39(sp)
226 |.define TMPD, TMPD_HI
227 |.define TONUM_D, TONUM_HI
228 |
229 |.endif
230 |.else
231 |
232 |.if FPU
233 |.define SAVE_LR, 276(sp)
234 |.define CFRAME_SPACE, 272 // Delta for sp.
235 |// Back chain for sp: 272(sp) <-- sp entering interpreter
236 |.define SAVE_FPR_, 128 // .. 128+18*8: 64 bit FPR saves.
237 |.else
238 |.define SAVE_LR, 132(sp)
239 |.define CFRAME_SPACE, 128 // Delta for sp.
240 |// Back chain for sp: 128(sp) <-- sp entering interpreter
241 |.endif
242 |.define SAVE_GPR_, 56 // .. 56+18*4: 32 bit GPR saves.
243 |.define SAVE_CR, 52(sp) // 32 bit CR save.
244 |.define SAVE_ERRF, 48(sp) // 32 bit C frame info.
245 |.define SAVE_NRES, 44(sp)
246 |.define SAVE_CFRAME, 40(sp)
247 |.define SAVE_L, 36(sp)
248 |.define SAVE_PC, 32(sp)
249 |.define SAVE_MULTRES, 28(sp)
250 |.define UNUSED1, 24(sp)
251 |.if FPU
252 |.define TMPD_LO, 20(sp)
253 |.define TMPD_HI, 16(sp)
254 |.define TONUM_LO, 12(sp)
255 |.define TONUM_HI, 8(sp)
256 |.else
257 |.define SFSAVE_4, 20(sp)
258 |.define SFSAVE_3, 16(sp)
259 |.define SFSAVE_2, 12(sp)
260 |.define SFSAVE_1, 8(sp)
261 |.endif
262 |// Next frame lr: 4(sp)
263 |// Back chain for sp: 0(sp) <-- sp while in interpreter
264 |
265 |.if FPU
266 |.define TMPD_BLO, 23(sp)
267 |.define TMPD, TMPD_HI
268 |.define TONUM_D, TONUM_HI
269 |.endif
270 |
271 |.endif
272 |
273 |.macro save_, reg
274 |.if GPR64
275 | std r..reg, SAVE_GPR_+(reg-14)*8(sp)
276 |.else
277 | stw r..reg, SAVE_GPR_+(reg-14)*4(sp)
278 |.endif
279 | .FPU stfd f..reg, SAVE_FPR_+(reg-14)*8(sp)
280 |.endmacro
281 |.macro rest_, reg
282 |.if GPR64
283 | ld r..reg, SAVE_GPR_+(reg-14)*8(sp)
284 |.else
285 | lwz r..reg, SAVE_GPR_+(reg-14)*4(sp)
286 |.endif
287 | .FPU lfd f..reg, SAVE_FPR_+(reg-14)*8(sp)
288 |.endmacro
289 |
290 |.macro saveregs
291 |.if GPR64 and not FRAME32
292 | stdu sp, -CFRAME_SPACE(sp)
293 |.else
294 | stwu sp, -CFRAME_SPACE(sp)
295 |.endif
296 | save_ 14; save_ 15; save_ 16
297 | mflr r0
298 | save_ 17; save_ 18; save_ 19; save_ 20; save_ 21; save_ 22
299 |.if GPR64 and not FRAME32
300 | std r0, SAVE_LR
301 |.else
302 | stw r0, SAVE_LR
303 |.endif
304 | save_ 23; save_ 24; save_ 25
305 | mfcr r0
306 | save_ 26; save_ 27; save_ 28; save_ 29; save_ 30; save_ 31
307 |.if GPR64
308 | std r0, SAVE_CR
309 |.else
310 | stw r0, SAVE_CR
311 |.endif
312 | .toc std TOCREG, SAVE_TOC
313 |.endmacro
314 |
315 |.macro restoreregs
316 |.if GPR64 and not FRAME32
317 | ld r0, SAVE_LR
318 |.else
319 | lwz r0, SAVE_LR
320 |.endif
321 |.if GPR64
322 | ld r12, SAVE_CR
323 |.else
324 | lwz r12, SAVE_CR
325 |.endif
326 | rest_ 14; rest_ 15; rest_ 16; rest_ 17; rest_ 18; rest_ 19
327 | mtlr r0;
328 |.if PPE; mtocrf 0x20, r12; .else; mtcrf 0x38, r12; .endif
329 | rest_ 20; rest_ 21; rest_ 22; rest_ 23; rest_ 24; rest_ 25
330 |.if PPE; mtocrf 0x10, r12; .endif
331 | rest_ 26; rest_ 27; rest_ 28; rest_ 29; rest_ 30; rest_ 31
332 |.if PPE; mtocrf 0x08, r12; .endif
333 | addi sp, sp, CFRAME_SPACE
334 |.endmacro
335 |
336 |// Type definitions. Some of these are only used for documentation.
337 |.type L, lua_State, LREG
338 |.type GL, global_State
339 |.type TVALUE, TValue
340 |.type GCOBJ, GCobj
341 |.type STR, GCstr
342 |.type TAB, GCtab
343 |.type LFUNC, GCfuncL
344 |.type CFUNC, GCfuncC
345 |.type PROTO, GCproto
346 |.type UPVAL, GCupval
347 |.type NODE, Node
348 |.type NARGS8, int
349 |.type TRACE, GCtrace
350 |.type SBUF, SBuf
351 |
352 |//-----------------------------------------------------------------------
353 |
354 |// Trap for not-yet-implemented parts.
355 |.macro NYI; tw 4, sp, sp; .endmacro
356 |
357 |.if FPU
358 |// int/FP conversions.
359 |.macro tonum_i, freg, reg
360 | xoris reg, reg, 0x8000
361 | stw reg, TONUM_LO
362 | lfd freg, TONUM_D
363 | fsub freg, freg, TONUM
364 |.endmacro
365 |
366 |.macro tonum_u, freg, reg
367 | stw reg, TONUM_LO
368 | lfd freg, TONUM_D
369 | fsub freg, freg, TOBIT
370 |.endmacro
371 |
372 |.macro toint, reg, freg, tmpfreg
373 | fctiwz tmpfreg, freg
374 | stfd tmpfreg, TMPD
375 | lwz reg, TMPD_LO
376 |.endmacro
377 |
378 |.macro toint, reg, freg
379 | toint reg, freg, freg
380 |.endmacro
381 |.endif
382 |
383 |//-----------------------------------------------------------------------
384 |
385 |// Access to frame relative to BASE.
386 |.define FRAME_PC, -8
387 |.define FRAME_FUNC, -4
388 |
389 |// Instruction decode.
390 |.macro decode_OP4, dst, ins; rlwinm dst, ins, 2, 22, 29; .endmacro
391 |.macro decode_OP8, dst, ins; rlwinm dst, ins, 3, 21, 28; .endmacro
392 |.macro decode_RA8, dst, ins; rlwinm dst, ins, 27, 21, 28; .endmacro
393 |.macro decode_RB8, dst, ins; rlwinm dst, ins, 11, 21, 28; .endmacro
394 |.macro decode_RC8, dst, ins; rlwinm dst, ins, 19, 21, 28; .endmacro
395 |.macro decode_RD8, dst, ins; rlwinm dst, ins, 19, 13, 28; .endmacro
396 |
397 |.macro decode_OP1, dst, ins; rlwinm dst, ins, 0, 24, 31; .endmacro
398 |.macro decode_RD4, dst, ins; rlwinm dst, ins, 18, 14, 29; .endmacro
399 |
400 |// Instruction fetch.
401 |.macro ins_NEXT1
402 | lwz INS, 0(PC)
403 | addi PC, PC, 4
404 |.endmacro
405 |// Instruction decode+dispatch. Note: optimized for e300!
406 |.macro ins_NEXT2
407 | decode_OPP TMP1, INS
408 | lpx TMP0, DISPATCH, TMP1
409 | mtctr TMP0
410 | decode_RB8 RB, INS
411 | decode_RD8 RD, INS
412 | decode_RA8 RA, INS
413 | decode_RC8 RC, INS
414 | bctr
415 |.endmacro
416 |.macro ins_NEXT
417 | ins_NEXT1
418 | ins_NEXT2
419 |.endmacro
420 |
421 |// Instruction footer.
422 |.if 1
423 | // Replicated dispatch. Less unpredictable branches, but higher I-Cache use.
424 | .define ins_next, ins_NEXT
425 | .define ins_next_, ins_NEXT
426 | .define ins_next1, ins_NEXT1
427 | .define ins_next2, ins_NEXT2
428 |.else
429 | // Common dispatch. Lower I-Cache use, only one (very) unpredictable branch.
430 | // Affects only certain kinds of benchmarks (and only with -j off).
431 | .macro ins_next
432 | b ->ins_next
433 | .endmacro
434 | .macro ins_next1
435 | .endmacro
436 | .macro ins_next2
437 | b ->ins_next
438 | .endmacro
439 | .macro ins_next_
440 | ->ins_next:
441 | ins_NEXT
442 | .endmacro
443 |.endif
444 |
445 |// Call decode and dispatch.
446 |.macro ins_callt
447 | // BASE = new base, RB = LFUNC/CFUNC, RC = nargs*8, FRAME_PC(BASE) = PC
448 | lwz PC, LFUNC:RB->pc
449 | lwz INS, 0(PC)
450 | addi PC, PC, 4
451 | decode_OPP TMP1, INS
452 | decode_RA8 RA, INS
453 | lpx TMP0, DISPATCH, TMP1
454 | add RA, RA, BASE
455 | mtctr TMP0
456 | bctr
457 |.endmacro
458 |
459 |.macro ins_call
460 | // BASE = new base, RB = LFUNC/CFUNC, RC = nargs*8, PC = caller PC
461 | stw PC, FRAME_PC(BASE)
462 | ins_callt
463 |.endmacro
464 |
465 |//-----------------------------------------------------------------------
466 |
467 |// Macros to test operand types.
468 |.macro checknum, reg; cmplw reg, TISNUM; .endmacro
469 |.macro checknum, cr, reg; cmplw cr, reg, TISNUM; .endmacro
470 |.macro checkstr, reg; cmpwi reg, LJ_TSTR; .endmacro
471 |.macro checktab, reg; cmpwi reg, LJ_TTAB; .endmacro
472 |.macro checkfunc, reg; cmpwi reg, LJ_TFUNC; .endmacro
473 |.macro checknil, reg; cmpwi reg, LJ_TNIL; .endmacro
474 |
475 |.macro branch_RD
476 | srwi TMP0, RD, 1
477 | addis PC, PC, -(BCBIAS_J*4 >> 16)
478 | add PC, PC, TMP0
479 |.endmacro
480 |
481 |// Assumes DISPATCH is relative to GL.
482 #define DISPATCH_GL(field) (GG_DISP2G + (int)offsetof(global_State, field))
483 #define DISPATCH_J(field) (GG_DISP2J + (int)offsetof(jit_State, field))
484 |
485 #define PC2PROTO(field) ((int)offsetof(GCproto, field)-(int)sizeof(GCproto))
486 |
487 |.macro hotcheck, delta, target
488 | rlwinm TMP1, PC, 31, 25, 30
489 | addi TMP1, TMP1, GG_DISP2HOT
490 | lhzx TMP2, DISPATCH, TMP1
491 | addic. TMP2, TMP2, -delta
492 | sthx TMP2, DISPATCH, TMP1
493 | blt target
494 |.endmacro
495 |
496 |.macro hotloop
497 | hotcheck HOTCOUNT_LOOP, ->vm_hotloop
498 |.endmacro
499 |
500 |.macro hotcall
501 | hotcheck HOTCOUNT_CALL, ->vm_hotcall
502 |.endmacro
503 |
504 |// Set current VM state. Uses TMP0.
505 |.macro li_vmstate, st; li TMP0, ~LJ_VMST_..st; .endmacro
506 |.macro st_vmstate; stw TMP0, DISPATCH_GL(vmstate)(DISPATCH); .endmacro
507 |
508 |// Move table write barrier back. Overwrites mark and tmp.
509 |.macro barrierback, tab, mark, tmp
510 | lwz tmp, DISPATCH_GL(gc.grayagain)(DISPATCH)
511 | // Assumes LJ_GC_BLACK is 0x04.
512 | rlwinm mark, mark, 0, 30, 28 // black2gray(tab)
513 | stw tab, DISPATCH_GL(gc.grayagain)(DISPATCH)
514 | stb mark, tab->marked
515 | stw tmp, tab->gclist
516 |.endmacro
517 |
518 |//-----------------------------------------------------------------------
519
520 /* Generate subroutines used by opcodes and other parts of the VM. */
521 /* The .code_sub section should be last to help static branch prediction. */
522 static void build_subroutines(BuildCtx *ctx)
523 {
524 |.code_sub
525 |
526 |//-----------------------------------------------------------------------
527 |//-- Return handling ----------------------------------------------------
528 |//-----------------------------------------------------------------------
529 |
530 |->vm_returnp:
531 | // See vm_return. Also: TMP2 = previous base.
532 | andix. TMP0, PC, FRAME_P
533 | li TMP1, LJ_TTRUE
534 | beq ->cont_dispatch
535 |
536 | // Return from pcall or xpcall fast func.
537 | lwz PC, FRAME_PC(TMP2) // Fetch PC of previous frame.
538 | mr BASE, TMP2 // Restore caller base.
539 | // Prepending may overwrite the pcall frame, so do it at the end.
540 | stwu TMP1, FRAME_PC(RA) // Prepend true to results.
541 |
542 |->vm_returnc:
543 | addi RD, RD, 8 // RD = (nresults+1)*8.
544 | andix. TMP0, PC, FRAME_TYPE
545 | cmpwi cr1, RD, 0
546 | li CRET1, LUA_YIELD
547 | beq cr1, ->vm_unwind_c_eh
548 | mr MULTRES, RD
549 | beq ->BC_RET_Z // Handle regular return to Lua.
550 |
551 |->vm_return:
552 | // BASE = base, RA = resultptr, RD/MULTRES = (nresults+1)*8, PC = return
553 | // TMP0 = PC & FRAME_TYPE
554 | cmpwi TMP0, FRAME_C
555 | rlwinm TMP2, PC, 0, 0, 28
556 | li_vmstate C
557 | sub TMP2, BASE, TMP2 // TMP2 = previous base.
558 | bney ->vm_returnp
559 |
560 | addic. TMP1, RD, -8
561 | stp TMP2, L->base
562 | lwz TMP2, SAVE_NRES
563 | subi BASE, BASE, 8
564 | st_vmstate
565 | slwi TMP2, TMP2, 3
566 | beq >2
567 |1:
568 | addic. TMP1, TMP1, -8
569 |.if FPU
570 | lfd f0, 0(RA)
571 |.else
572 | lwz CARG1, 0(RA)
573 | lwz CARG2, 4(RA)
574 |.endif
575 | addi RA, RA, 8
576 |.if FPU
577 | stfd f0, 0(BASE)
578 |.else
579 | stw CARG1, 0(BASE)
580 | stw CARG2, 4(BASE)
581 |.endif
582 | addi BASE, BASE, 8
583 | bney <1
584 |
585 |2:
586 | cmpw TMP2, RD // More/less results wanted?
587 | bne >6
588 |3:
589 | stp BASE, L->top // Store new top.
590 |
591 |->vm_leave_cp:
592 | lp TMP0, SAVE_CFRAME // Restore previous C frame.
593 | li CRET1, 0 // Ok return status for vm_pcall.
594 | stp TMP0, L->cframe
595 |
596 |->vm_leave_unw:
597 | restoreregs
598 | blr
599 |
600 |6:
601 | ble >7 // Less results wanted?
602 | // More results wanted. Check stack size and fill up results with nil.
603 | lwz TMP1, L->maxstack
604 | cmplw BASE, TMP1
605 | bge >8
606 | stw TISNIL, 0(BASE)
607 | addi RD, RD, 8
608 | addi BASE, BASE, 8
609 | b <2
610 |
611 |7: // Less results wanted.
612 | subfic TMP3, TMP2, 0 // LUA_MULTRET+1 case?
613 | sub TMP0, RD, TMP2
614 | subfe TMP1, TMP1, TMP1 // TMP1 = TMP2 == 0 ? 0 : -1
615 | and TMP0, TMP0, TMP1
616 | sub BASE, BASE, TMP0 // Either keep top or shrink it.
617 | b <3
618 |
619 |8: // Corner case: need to grow stack for filling up results.
620 | // This can happen if:
621 | // - A C function grows the stack (a lot).
622 | // - The GC shrinks the stack in between.
623 | // - A return back from a lua_call() with (high) nresults adjustment.
624 | stp BASE, L->top // Save current top held in BASE (yes).
625 | mr SAVE0, RD
626 | srwi CARG2, TMP2, 3
627 | mr CARG1, L
628 | bl extern lj_state_growstack // (lua_State *L, int n)
629 | lwz TMP2, SAVE_NRES
630 | mr RD, SAVE0
631 | slwi TMP2, TMP2, 3
632 | lp BASE, L->top // Need the (realloced) L->top in BASE.
633 | b <2
634 |
635 |->vm_unwind_c: // Unwind C stack, return from vm_pcall.
636 | // (void *cframe, int errcode)
637 | mr sp, CARG1
638 | mr CRET1, CARG2
639 |->vm_unwind_c_eh: // Landing pad for external unwinder.
640 | lwz L, SAVE_L
641 | .toc ld TOCREG, SAVE_TOC
642 | li TMP0, ~LJ_VMST_C
643 | lwz GL:TMP1, L->glref
644 | stw TMP0, GL:TMP1->vmstate
645 | b ->vm_leave_unw
646 |
647 |->vm_unwind_ff: // Unwind C stack, return from ff pcall.
648 | // (void *cframe)
649 |.if GPR64
650 | rldicr sp, CARG1, 0, 61
651 |.else
652 | rlwinm sp, CARG1, 0, 0, 29
653 |.endif
654 |->vm_unwind_ff_eh: // Landing pad for external unwinder.
655 | lwz L, SAVE_L
656 | .toc ld TOCREG, SAVE_TOC
657 | li TISNUM, LJ_TISNUM // Setup type comparison constants.
658 | lp BASE, L->base
659 | .FPU lus TMP3, 0x59c0 // TOBIT = 2^52 + 2^51 (float).
660 | lwz DISPATCH, L->glref // Setup pointer to dispatch table.
661 | li ZERO, 0
662 | .FPU stw TMP3, TMPD
663 | li TMP1, LJ_TFALSE
664 | .FPU ori TMP3, TMP3, 0x0004 // TONUM = 2^52 + 2^51 + 2^31 (float).
665 | li TISNIL, LJ_TNIL
666 | li_vmstate INTERP
667 | .FPU lfs TOBIT, TMPD
668 | lwz PC, FRAME_PC(BASE) // Fetch PC of previous frame.
669 | la RA, -8(BASE) // Results start at BASE-8.
670 | .FPU stw TMP3, TMPD
671 | addi DISPATCH, DISPATCH, GG_G2DISP
672 | stw TMP1, 0(RA) // Prepend false to error message.
673 | li RD, 16 // 2 results: false + error message.
674 | st_vmstate
675 | .FPU lfs TONUM, TMPD
676 | b ->vm_returnc
677 |
678 |//-----------------------------------------------------------------------
679 |//-- Grow stack for calls -----------------------------------------------
680 |//-----------------------------------------------------------------------
681 |
682 |->vm_growstack_c: // Grow stack for C function.
683 | li CARG2, LUA_MINSTACK
684 | b >2
685 |
686 |->vm_growstack_l: // Grow stack for Lua function.
687 | // BASE = new base, RA = BASE+framesize*8, RC = nargs*8, PC = first PC
688 | add RC, BASE, RC
689 | sub RA, RA, BASE
690 | stp BASE, L->base
691 | addi PC, PC, 4 // Must point after first instruction.
692 | stp RC, L->top
693 | srwi CARG2, RA, 3
694 |2:
695 | // L->base = new base, L->top = top
696 | stw PC, SAVE_PC
697 | mr CARG1, L
698 | bl extern lj_state_growstack // (lua_State *L, int n)
699 | lp BASE, L->base
700 | lp RC, L->top
701 | lwz LFUNC:RB, FRAME_FUNC(BASE)
702 | sub RC, RC, BASE
703 | // BASE = new base, RB = LFUNC/CFUNC, RC = nargs*8, FRAME_PC(BASE) = PC
704 | ins_callt // Just retry the call.
705 |
706 |//-----------------------------------------------------------------------
707 |//-- Entry points into the assembler VM ---------------------------------
708 |//-----------------------------------------------------------------------
709 |
710 |->vm_resume: // Setup C frame and resume thread.
711 | // (lua_State *L, TValue *base, int nres1 = 0, ptrdiff_t ef = 0)
712 | saveregs
713 | mr L, CARG1
714 | lwz DISPATCH, L->glref // Setup pointer to dispatch table.
715 | mr BASE, CARG2
716 | lbz TMP1, L->status
717 | stw L, SAVE_L
718 | li PC, FRAME_CP
719 | addi TMP0, sp, CFRAME_RESUME
720 | addi DISPATCH, DISPATCH, GG_G2DISP
721 | stw CARG3, SAVE_NRES
722 | cmplwi TMP1, 0
723 | stw CARG3, SAVE_ERRF
724 | stp CARG3, SAVE_CFRAME
725 | stw CARG1, SAVE_PC // Any value outside of bytecode is ok.
726 | stp TMP0, L->cframe
727 | beq >3
728 |
729 | // Resume after yield (like a return).
730 | stw L, DISPATCH_GL(cur_L)(DISPATCH)
731 | mr RA, BASE
732 | lp BASE, L->base
733 | li TISNUM, LJ_TISNUM // Setup type comparison constants.
734 | lp TMP1, L->top
735 | lwz PC, FRAME_PC(BASE)
736 | .FPU lus TMP3, 0x59c0 // TOBIT = 2^52 + 2^51 (float).
737 | stb CARG3, L->status
738 | .FPU stw TMP3, TMPD
739 | .FPU ori TMP3, TMP3, 0x0004 // TONUM = 2^52 + 2^51 + 2^31 (float).
740 | .FPU lfs TOBIT, TMPD
741 | sub RD, TMP1, BASE
742 | .FPU stw TMP3, TMPD
743 | .FPU lus TMP0, 0x4338 // Hiword of 2^52 + 2^51 (double)
744 | addi RD, RD, 8
745 | .FPU stw TMP0, TONUM_HI
746 | li_vmstate INTERP
747 | li ZERO, 0
748 | st_vmstate
749 | andix. TMP0, PC, FRAME_TYPE
750 | mr MULTRES, RD
751 | .FPU lfs TONUM, TMPD
752 | li TISNIL, LJ_TNIL
753 | beq ->BC_RET_Z
754 | b ->vm_return
755 |
756 |->vm_pcall: // Setup protected C frame and enter VM.
757 | // (lua_State *L, TValue *base, int nres1, ptrdiff_t ef)
758 | saveregs
759 | li PC, FRAME_CP
760 | stw CARG4, SAVE_ERRF
761 | b >1
762 |
763 |->vm_call: // Setup C frame and enter VM.
764 | // (lua_State *L, TValue *base, int nres1)
765 | saveregs
766 | li PC, FRAME_C
767 |
768 |1: // Entry point for vm_pcall above (PC = ftype).
769 | lp TMP1, L:CARG1->cframe
770 | mr L, CARG1
771 | stw CARG3, SAVE_NRES
772 | lwz DISPATCH, L->glref // Setup pointer to dispatch table.
773 | stw CARG1, SAVE_L
774 | mr BASE, CARG2
775 | addi DISPATCH, DISPATCH, GG_G2DISP
776 | stw CARG1, SAVE_PC // Any value outside of bytecode is ok.
777 | stp TMP1, SAVE_CFRAME
778 | stp sp, L->cframe // Add our C frame to cframe chain.
779 |
780 |3: // Entry point for vm_cpcall/vm_resume (BASE = base, PC = ftype).
781 | stw L, DISPATCH_GL(cur_L)(DISPATCH)
782 | lp TMP2, L->base // TMP2 = old base (used in vmeta_call).
783 | li TISNUM, LJ_TISNUM // Setup type comparison constants.
784 | lp TMP1, L->top
785 | .FPU lus TMP3, 0x59c0 // TOBIT = 2^52 + 2^51 (float).
786 | add PC, PC, BASE
787 | .FPU stw TMP3, TMPD
788 | li ZERO, 0
789 | .FPU ori TMP3, TMP3, 0x0004 // TONUM = 2^52 + 2^51 + 2^31 (float).
790 | .FPU lfs TOBIT, TMPD
791 | sub PC, PC, TMP2 // PC = frame delta + frame type
792 | .FPU stw TMP3, TMPD
793 | .FPU lus TMP0, 0x4338 // Hiword of 2^52 + 2^51 (double)
794 | sub NARGS8:RC, TMP1, BASE
795 | .FPU stw TMP0, TONUM_HI
796 | li_vmstate INTERP
797 | .FPU lfs TONUM, TMPD
798 | li TISNIL, LJ_TNIL
799 | st_vmstate
800 |
801 |->vm_call_dispatch:
802 | // TMP2 = old base, BASE = new base, RC = nargs*8, PC = caller PC
803 | lwz TMP0, FRAME_PC(BASE)
804 | lwz LFUNC:RB, FRAME_FUNC(BASE)
805 | checkfunc TMP0; bne ->vmeta_call
806 |
807 |->vm_call_dispatch_f:
808 | ins_call
809 | // BASE = new base, RB = func, RC = nargs*8, PC = caller PC
810 |
811 |->vm_cpcall: // Setup protected C frame, call C.
812 | // (lua_State *L, lua_CFunction func, void *ud, lua_CPFunction cp)
813 | saveregs
814 | mr L, CARG1
815 | lwz TMP0, L:CARG1->stack
816 | stw CARG1, SAVE_L
817 | lp TMP1, L->top
818 | lwz DISPATCH, L->glref // Setup pointer to dispatch table.
819 | stw CARG1, SAVE_PC // Any value outside of bytecode is ok.
820 | sub TMP0, TMP0, TMP1 // Compute -savestack(L, L->top).
821 | lp TMP1, L->cframe
822 | addi DISPATCH, DISPATCH, GG_G2DISP
823 | .toc lp CARG4, 0(CARG4)
824 | li TMP2, 0
825 | stw TMP0, SAVE_NRES // Neg. delta means cframe w/o frame.
826 | stw TMP2, SAVE_ERRF // No error function.
827 | stp TMP1, SAVE_CFRAME
828 | stp sp, L->cframe // Add our C frame to cframe chain.
829 | stw L, DISPATCH_GL(cur_L)(DISPATCH)
830 | mtctr CARG4
831 | bctrl // (lua_State *L, lua_CFunction func, void *ud)
832 |.if PPE
833 | mr BASE, CRET1
834 | cmpwi CRET1, 0
835 |.else
836 | mr. BASE, CRET1
837 |.endif
838 | li PC, FRAME_CP
839 | bne <3 // Else continue with the call.
840 | b ->vm_leave_cp // No base? Just remove C frame.
841 |
842 |//-----------------------------------------------------------------------
843 |//-- Metamethod handling ------------------------------------------------
844 |//-----------------------------------------------------------------------
845 |
846 |// The lj_meta_* functions (except for lj_meta_cat) don't reallocate the
847 |// stack, so BASE doesn't need to be reloaded across these calls.
848 |
849 |//-- Continuation dispatch ----------------------------------------------
850 |
851 |->cont_dispatch:
852 | // BASE = meta base, RA = resultptr, RD = (nresults+1)*8
853 | lwz TMP0, -12(BASE) // Continuation.
854 | mr RB, BASE
855 | mr BASE, TMP2 // Restore caller BASE.
856 | lwz LFUNC:TMP1, FRAME_FUNC(TMP2)
857 |.if FFI
858 | cmplwi TMP0, 1
859 |.endif
860 | lwz PC, -16(RB) // Restore PC from [cont|PC].
861 | subi TMP2, RD, 8
862 | stwx TISNIL, RA, TMP2 // Ensure one valid arg.
863 |.if FFI
864 | ble >1
865 |.endif
866 | lwz TMP1, LFUNC:TMP1->pc
867 | lwz KBASE, PC2PROTO(k)(TMP1)
868 | // BASE = base, RA = resultptr, RB = meta base
869 | mtctr TMP0
870 | bctr // Jump to continuation.
871 |
872 |.if FFI
873 |1:
874 | beq ->cont_ffi_callback // cont = 1: return from FFI callback.
875 | // cont = 0: tailcall from C function.
876 | subi TMP1, RB, 16
877 | sub RC, TMP1, BASE
878 | b ->vm_call_tail
879 |.endif
880 |
881 |->cont_cat: // RA = resultptr, RB = meta base
882 | lwz INS, -4(PC)
883 | subi CARG2, RB, 16
884 | decode_RB8 SAVE0, INS
885 |.if FPU
886 | lfd f0, 0(RA)
887 |.else
888 | lwz TMP2, 0(RA)
889 | lwz TMP3, 4(RA)
890 |.endif
891 | add TMP1, BASE, SAVE0
892 | stp BASE, L->base
893 | cmplw TMP1, CARG2
894 | sub CARG3, CARG2, TMP1
895 | decode_RA8 RA, INS
896 |.if FPU
897 | stfd f0, 0(CARG2)
898 |.else
899 | stw TMP2, 0(CARG2)
900 | stw TMP3, 4(CARG2)
901 |.endif
902 | bney ->BC_CAT_Z
903 |.if FPU
904 | stfdx f0, BASE, RA
905 |.else
906 | stwux TMP2, RA, BASE
907 | stw TMP3, 4(RA)
908 |.endif
909 | b ->cont_nop
910 |
911 |//-- Table indexing metamethods -----------------------------------------
912 |
913 |->vmeta_tgets1:
914 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
915 | li TMP0, LJ_TSTR
916 | decode_RB8 RB, INS
917 | stw STR:RC, 4(CARG3)
918 | add CARG2, BASE, RB
919 | stw TMP0, 0(CARG3)
920 | b >1
921 |
922 |->vmeta_tgets:
923 | la CARG2, DISPATCH_GL(tmptv)(DISPATCH)
924 | li TMP0, LJ_TTAB
925 | stw TAB:RB, 4(CARG2)
926 | la CARG3, DISPATCH_GL(tmptv2)(DISPATCH)
927 | stw TMP0, 0(CARG2)
928 | li TMP1, LJ_TSTR
929 | stw STR:RC, 4(CARG3)
930 | stw TMP1, 0(CARG3)
931 | b >1
932 |
933 |->vmeta_tgetb: // TMP0 = index
934 |.if not DUALNUM
935 | tonum_u f0, TMP0
936 |.endif
937 | decode_RB8 RB, INS
938 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
939 | add CARG2, BASE, RB
940 |.if DUALNUM
941 | stw TISNUM, 0(CARG3)
942 | stw TMP0, 4(CARG3)
943 |.else
944 | stfd f0, 0(CARG3)
945 |.endif
946 | b >1
947 |
948 |->vmeta_tgetv:
949 | decode_RB8 RB, INS
950 | decode_RC8 RC, INS
951 | add CARG2, BASE, RB
952 | add CARG3, BASE, RC
953 |1:
954 | stp BASE, L->base
955 | mr CARG1, L
956 | stw PC, SAVE_PC
957 | bl extern lj_meta_tget // (lua_State *L, TValue *o, TValue *k)
958 | // Returns TValue * (finished) or NULL (metamethod).
959 | cmplwi CRET1, 0
960 | beq >3
961 |.if FPU
962 | lfd f0, 0(CRET1)
963 |.else
964 | lwz TMP0, 0(CRET1)
965 | lwz TMP1, 4(CRET1)
966 |.endif
967 | ins_next1
968 |.if FPU
969 | stfdx f0, BASE, RA
970 |.else
971 | stwux TMP0, RA, BASE
972 | stw TMP1, 4(RA)
973 |.endif
974 | ins_next2
975 |
976 |3: // Call __index metamethod.
977 | // BASE = base, L->top = new base, stack = cont/func/t/k
978 | subfic TMP1, BASE, FRAME_CONT
979 | lp BASE, L->top
980 | stw PC, -16(BASE) // [cont|PC]
981 | add PC, TMP1, BASE
982 | lwz LFUNC:RB, FRAME_FUNC(BASE) // Guaranteed to be a function here.
983 | li NARGS8:RC, 16 // 2 args for func(t, k).
984 | b ->vm_call_dispatch_f
985 |
986 |->vmeta_tgetr:
987 | bl extern lj_tab_getinth // (GCtab *t, int32_t key)
988 | // Returns cTValue * or NULL.
989 | cmplwi CRET1, 0
990 | beq >1
991 |.if FPU
992 | lfd f14, 0(CRET1)
993 |.else
994 | lwz SAVE0, 0(CRET1)
995 | lwz SAVE1, 4(CRET1)
996 |.endif
997 | b ->BC_TGETR_Z
998 |1:
999 | stwx TISNIL, BASE, RA
1000 | b ->cont_nop
1001 |
1002 |//-----------------------------------------------------------------------
1003 |
1004 |->vmeta_tsets1:
1005 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
1006 | li TMP0, LJ_TSTR
1007 | decode_RB8 RB, INS
1008 | stw STR:RC, 4(CARG3)
1009 | add CARG2, BASE, RB
1010 | stw TMP0, 0(CARG3)
1011 | b >1
1012 |
1013 |->vmeta_tsets:
1014 | la CARG2, DISPATCH_GL(tmptv)(DISPATCH)
1015 | li TMP0, LJ_TTAB
1016 | stw TAB:RB, 4(CARG2)
1017 | la CARG3, DISPATCH_GL(tmptv2)(DISPATCH)
1018 | stw TMP0, 0(CARG2)
1019 | li TMP1, LJ_TSTR
1020 | stw STR:RC, 4(CARG3)
1021 | stw TMP1, 0(CARG3)
1022 | b >1
1023 |
1024 |->vmeta_tsetb: // TMP0 = index
1025 |.if not DUALNUM
1026 | tonum_u f0, TMP0
1027 |.endif
1028 | decode_RB8 RB, INS
1029 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
1030 | add CARG2, BASE, RB
1031 |.if DUALNUM
1032 | stw TISNUM, 0(CARG3)
1033 | stw TMP0, 4(CARG3)
1034 |.else
1035 | stfd f0, 0(CARG3)
1036 |.endif
1037 | b >1
1038 |
1039 |->vmeta_tsetv:
1040 | decode_RB8 RB, INS
1041 | decode_RC8 RC, INS
1042 | add CARG2, BASE, RB
1043 | add CARG3, BASE, RC
1044 |1:
1045 | stp BASE, L->base
1046 | mr CARG1, L
1047 | stw PC, SAVE_PC
1048 | bl extern lj_meta_tset // (lua_State *L, TValue *o, TValue *k)
1049 | // Returns TValue * (finished) or NULL (metamethod).
1050 | cmplwi CRET1, 0
1051 |.if FPU
1052 | lfdx f0, BASE, RA
1053 |.else
1054 | lwzux TMP2, RA, BASE
1055 | lwz TMP3, 4(RA)
1056 |.endif
1057 | beq >3
1058 | // NOBARRIER: lj_meta_tset ensures the table is not black.
1059 | ins_next1
1060 |.if FPU
1061 | stfd f0, 0(CRET1)
1062 |.else
1063 | stw TMP2, 0(CRET1)
1064 | stw TMP3, 4(CRET1)
1065 |.endif
1066 | ins_next2
1067 |
1068 |3: // Call __newindex metamethod.
1069 | // BASE = base, L->top = new base, stack = cont/func/t/k/(v)
1070 | subfic TMP1, BASE, FRAME_CONT
1071 | lp BASE, L->top
1072 | stw PC, -16(BASE) // [cont|PC]
1073 | add PC, TMP1, BASE
1074 | lwz LFUNC:RB, FRAME_FUNC(BASE) // Guaranteed to be a function here.
1075 | li NARGS8:RC, 24 // 3 args for func(t, k, v)
1076 |.if FPU
1077 | stfd f0, 16(BASE) // Copy value to third argument.
1078 |.else
1079 | stw TMP2, 16(BASE)
1080 | stw TMP3, 20(BASE)
1081 |.endif
1082 | b ->vm_call_dispatch_f
1083 |
1084 |->vmeta_tsetr:
1085 | stp BASE, L->base
1086 | mr CARG1, L
1087 | stw PC, SAVE_PC
1088 | bl extern lj_tab_setinth // (lua_State *L, GCtab *t, int32_t key)
1089 | // Returns TValue *.
1090 |.if FPU
1091 | stfd f14, 0(CRET1)
1092 |.else
1093 | stw SAVE0, 0(CRET1)
1094 | stw SAVE1, 4(CRET1)
1095 |.endif
1096 | b ->cont_nop
1097 |
1098 |//-- Comparison metamethods ---------------------------------------------
1099 |
1100 |->vmeta_comp:
1101 | mr CARG1, L
1102 | subi PC, PC, 4
1103 |.if DUALNUM
1104 | mr CARG2, RA
1105 |.else
1106 | add CARG2, BASE, RA
1107 |.endif
1108 | stw PC, SAVE_PC
1109 |.if DUALNUM
1110 | mr CARG3, RD
1111 |.else
1112 | add CARG3, BASE, RD
1113 |.endif
1114 | stp BASE, L->base
1115 | decode_OP1 CARG4, INS
1116 | bl extern lj_meta_comp // (lua_State *L, TValue *o1, *o2, int op)
1117 | // Returns 0/1 or TValue * (metamethod).
1118 |3:
1119 | cmplwi CRET1, 1
1120 | bgt ->vmeta_binop
1121 | subfic CRET1, CRET1, 0
1122 |4:
1123 | lwz INS, 0(PC)
1124 | addi PC, PC, 4
1125 | decode_RD4 TMP2, INS
1126 | addis TMP2, TMP2, -(BCBIAS_J*4 >> 16)
1127 | and TMP2, TMP2, CRET1
1128 | add PC, PC, TMP2
1129 |->cont_nop:
1130 | ins_next
1131 |
1132 |->cont_ra: // RA = resultptr
1133 | lwz INS, -4(PC)
1134 |.if FPU
1135 | lfd f0, 0(RA)
1136 |.else
1137 | lwz CARG1, 0(RA)
1138 | lwz CARG2, 4(RA)
1139 |.endif
1140 | decode_RA8 TMP1, INS
1141 |.if FPU
1142 | stfdx f0, BASE, TMP1
1143 |.else
1144 | stwux CARG1, TMP1, BASE
1145 | stw CARG2, 4(TMP1)
1146 |.endif
1147 | b ->cont_nop
1148 |
1149 |->cont_condt: // RA = resultptr
1150 | lwz TMP0, 0(RA)
1151 | .gpr64 extsw TMP0, TMP0
1152 | subfic TMP0, TMP0, LJ_TTRUE // Branch if result is true.
1153 | subfe CRET1, CRET1, CRET1
1154 | not CRET1, CRET1
1155 | b <4
1156 |
1157 |->cont_condf: // RA = resultptr
1158 | lwz TMP0, 0(RA)
1159 | .gpr64 extsw TMP0, TMP0
1160 | subfic TMP0, TMP0, LJ_TTRUE // Branch if result is false.
1161 | subfe CRET1, CRET1, CRET1
1162 | b <4
1163 |
1164 |->vmeta_equal:
1165 | // CARG2, CARG3, CARG4 are already set by BC_ISEQV/BC_ISNEV.
1166 | subi PC, PC, 4
1167 | stp BASE, L->base
1168 | mr CARG1, L
1169 | stw PC, SAVE_PC
1170 | bl extern lj_meta_equal // (lua_State *L, GCobj *o1, *o2, int ne)
1171 | // Returns 0/1 or TValue * (metamethod).
1172 | b <3
1173 |
1174 |->vmeta_equal_cd:
1175 |.if FFI
1176 | mr CARG2, INS
1177 | subi PC, PC, 4
1178 | stp BASE, L->base
1179 | mr CARG1, L
1180 | stw PC, SAVE_PC
1181 | bl extern lj_meta_equal_cd // (lua_State *L, BCIns op)
1182 | // Returns 0/1 or TValue * (metamethod).
1183 | b <3
1184 |.endif
1185 |
1186 |->vmeta_istype:
1187 | subi PC, PC, 4
1188 | stp BASE, L->base
1189 | srwi CARG2, RA, 3
1190 | mr CARG1, L
1191 | srwi CARG3, RD, 3
1192 | stw PC, SAVE_PC
1193 | bl extern lj_meta_istype // (lua_State *L, BCReg ra, BCReg tp)
1194 | b ->cont_nop
1195 |
1196 |//-- Arithmetic metamethods ---------------------------------------------
1197 |
1198 |->vmeta_arith_nv:
1199 | add CARG3, KBASE, RC
1200 | add CARG4, BASE, RB
1201 | b >1
1202 |->vmeta_arith_nv2:
1203 |.if DUALNUM
1204 | mr CARG3, RC
1205 | mr CARG4, RB
1206 | b >1
1207 |.endif
1208 |
1209 |->vmeta_unm:
1210 | mr CARG3, RD
1211 | mr CARG4, RD
1212 | b >1
1213 |
1214 |->vmeta_arith_vn:
1215 | add CARG3, BASE, RB
1216 | add CARG4, KBASE, RC
1217 | b >1
1218 |
1219 |->vmeta_arith_vv:
1220 | add CARG3, BASE, RB
1221 | add CARG4, BASE, RC
1222 |.if DUALNUM
1223 | b >1
1224 |.endif
1225 |->vmeta_arith_vn2:
1226 |->vmeta_arith_vv2:
1227 |.if DUALNUM
1228 | mr CARG3, RB
1229 | mr CARG4, RC
1230 |.endif
1231 |1:
1232 | add CARG2, BASE, RA
1233 | stp BASE, L->base
1234 | mr CARG1, L
1235 | stw PC, SAVE_PC
1236 | decode_OP1 CARG5, INS // Caveat: CARG5 overlaps INS.
1237 | bl extern lj_meta_arith // (lua_State *L, TValue *ra,*rb,*rc, BCReg op)
1238 | // Returns NULL (finished) or TValue * (metamethod).
1239 | cmplwi CRET1, 0
1240 | beq ->cont_nop
1241 |
1242 | // Call metamethod for binary op.
1243 |->vmeta_binop:
1244 | // BASE = old base, CRET1 = new base, stack = cont/func/o1/o2
1245 | sub TMP1, CRET1, BASE
1246 | stw PC, -16(CRET1) // [cont|PC]
1247 | mr TMP2, BASE
1248 | addi PC, TMP1, FRAME_CONT
1249 | mr BASE, CRET1
1250 | li NARGS8:RC, 16 // 2 args for func(o1, o2).
1251 | b ->vm_call_dispatch
1252 |
1253 |->vmeta_len:
1254 #if LJ_52
1255 | mr SAVE0, CARG1
1256 #endif
1257 | mr CARG2, RD
1258 | stp BASE, L->base
1259 | mr CARG1, L
1260 | stw PC, SAVE_PC
1261 | bl extern lj_meta_len // (lua_State *L, TValue *o)
1262 | // Returns NULL (retry) or TValue * (metamethod base).
1263 #if LJ_52
1264 | cmplwi CRET1, 0
1265 | bne ->vmeta_binop // Binop call for compatibility.
1266 | mr CARG1, SAVE0
1267 | b ->BC_LEN_Z
1268 #else
1269 | b ->vmeta_binop // Binop call for compatibility.
1270 #endif
1271 |
1272 |//-- Call metamethod ----------------------------------------------------
1273 |
1274 |->vmeta_call: // Resolve and call __call metamethod.
1275 | // TMP2 = old base, BASE = new base, RC = nargs*8
1276 | mr CARG1, L
1277 | stp TMP2, L->base // This is the callers base!
1278 | subi CARG2, BASE, 8
1279 | stw PC, SAVE_PC
1280 | add CARG3, BASE, RC
1281 | mr SAVE0, NARGS8:RC
1282 | bl extern lj_meta_call // (lua_State *L, TValue *func, TValue *top)
1283 | lwz LFUNC:RB, FRAME_FUNC(BASE) // Guaranteed to be a function here.
1284 | addi NARGS8:RC, SAVE0, 8 // Got one more argument now.
1285 | ins_call
1286 |
1287 |->vmeta_callt: // Resolve __call for BC_CALLT.
1288 | // BASE = old base, RA = new base, RC = nargs*8
1289 | mr CARG1, L
1290 | stp BASE, L->base
1291 | subi CARG2, RA, 8
1292 | stw PC, SAVE_PC
1293 | add CARG3, RA, RC
1294 | mr SAVE0, NARGS8:RC
1295 | bl extern lj_meta_call // (lua_State *L, TValue *func, TValue *top)
1296 | lwz TMP1, FRAME_PC(BASE)
1297 | addi NARGS8:RC, SAVE0, 8 // Got one more argument now.
1298 | lwz LFUNC:RB, FRAME_FUNC(RA) // Guaranteed to be a function here.
1299 | b ->BC_CALLT_Z
1300 |
1301 |//-- Argument coercion for 'for' statement ------------------------------
1302 |
1303 |->vmeta_for:
1304 | mr CARG1, L
1305 | stp BASE, L->base
1306 | mr CARG2, RA
1307 | stw PC, SAVE_PC
1308 | mr SAVE0, INS
1309 | bl extern lj_meta_for // (lua_State *L, TValue *base)
1310 |.if JIT
1311 | decode_OP1 TMP0, SAVE0
1312 |.endif
1313 | decode_RA8 RA, SAVE0
1314 |.if JIT
1315 | cmpwi TMP0, BC_JFORI
1316 |.endif
1317 | decode_RD8 RD, SAVE0
1318 |.if JIT
1319 | beqy =>BC_JFORI
1320 |.endif
1321 | b =>BC_FORI
1322 |
1323 |//-----------------------------------------------------------------------
1324 |//-- Fast functions -----------------------------------------------------
1325 |//-----------------------------------------------------------------------
1326 |
1327 |.macro .ffunc, name
1328 |->ff_ .. name:
1329 |.endmacro
1330 |
1331 |.macro .ffunc_1, name
1332 |->ff_ .. name:
1333 | cmplwi NARGS8:RC, 8
1334 | lwz CARG3, 0(BASE)
1335 | lwz CARG1, 4(BASE)
1336 | blt ->fff_fallback
1337 |.endmacro
1338 |
1339 |.macro .ffunc_2, name
1340 |->ff_ .. name:
1341 | cmplwi NARGS8:RC, 16
1342 | lwz CARG3, 0(BASE)
1343 | lwz CARG4, 8(BASE)
1344 | lwz CARG1, 4(BASE)
1345 | lwz CARG2, 12(BASE)
1346 | blt ->fff_fallback
1347 |.endmacro
1348 |
1349 |.macro .ffunc_n, name
1350 |->ff_ .. name:
1351 | cmplwi NARGS8:RC, 8
1352 | lwz CARG1, 0(BASE)
1353 |.if FPU
1354 | lfd FARG1, 0(BASE)
1355 |.else
1356 | lwz CARG2, 4(BASE)
1357 |.endif
1358 | blt ->fff_fallback
1359 | checknum CARG1; bge ->fff_fallback
1360 |.endmacro
1361 |
1362 |.macro .ffunc_nn, name
1363 |->ff_ .. name:
1364 | cmplwi NARGS8:RC, 16
1365 | lwz CARG1, 0(BASE)
1366 |.if FPU
1367 | lfd FARG1, 0(BASE)
1368 | lwz CARG3, 8(BASE)
1369 | lfd FARG2, 8(BASE)
1370 |.else
1371 | lwz CARG2, 4(BASE)
1372 | lwz CARG3, 8(BASE)
1373 | lwz CARG4, 12(BASE)
1374 |.endif
1375 | blt ->fff_fallback
1376 | checknum CARG1; bge ->fff_fallback
1377 | checknum CARG3; bge ->fff_fallback
1378 |.endmacro
1379 |
1380 |// Inlined GC threshold check. Caveat: uses TMP0 and TMP1.
1381 |.macro ffgccheck
1382 | lwz TMP0, DISPATCH_GL(gc.total)(DISPATCH)
1383 | lwz TMP1, DISPATCH_GL(gc.threshold)(DISPATCH)
1384 | cmplw TMP0, TMP1
1385 | bgel ->fff_gcstep
1386 |.endmacro
1387 |
1388 |//-- Base library: checks -----------------------------------------------
1389 |
1390 |.ffunc_1 assert
1391 | li TMP1, LJ_TFALSE
1392 | la RA, -8(BASE)
1393 | cmplw cr1, CARG3, TMP1
1394 | lwz PC, FRAME_PC(BASE)
1395 | bge cr1, ->fff_fallback
1396 | stw CARG3, 0(RA)
1397 | addi RD, NARGS8:RC, 8 // Compute (nresults+1)*8.
1398 | addi TMP1, BASE, 8
1399 | add TMP2, RA, NARGS8:RC
1400 | stw CARG1, 4(RA)
1401 | beq ->fff_res // Done if exactly 1 argument.
1402 |1:
1403 | cmplw TMP1, TMP2
1404 |.if FPU
1405 | lfd f0, 0(TMP1)
1406 | stfd f0, 0(TMP1)
1407 |.else
1408 | lwz CARG1, 0(TMP1)
1409 | lwz CARG2, 4(TMP1)
1410 | stw CARG1, -8(TMP1)
1411 | stw CARG2, -4(TMP1)
1412 |.endif
1413 | addi TMP1, TMP1, 8
1414 | bney <1
1415 | b ->fff_res
1416 |
1417 |.ffunc type
1418 | cmplwi NARGS8:RC, 8
1419 | lwz CARG1, 0(BASE)
1420 | blt ->fff_fallback
1421 | .gpr64 extsw CARG1, CARG1
1422 | subfc TMP0, TISNUM, CARG1
1423 | subfe TMP2, CARG1, CARG1
1424 | orc TMP1, TMP2, TMP0
1425 | addi TMP1, TMP1, ~LJ_TISNUM+1
1426 | slwi TMP1, TMP1, 3
1427 |.if FPU
1428 | la TMP2, CFUNC:RB->upvalue
1429 | lfdx FARG1, TMP2, TMP1
1430 |.else
1431 | add TMP1, CFUNC:RB, TMP1
1432 | lwz CARG1, CFUNC:TMP1->upvalue[0].u32.hi
1433 | lwz CARG2, CFUNC:TMP1->upvalue[0].u32.lo
1434 |.endif
1435 | b ->fff_resn
1436 |
1437 |//-- Base library: getters and setters ---------------------------------
1438 |
1439 |.ffunc_1 getmetatable
1440 | checktab CARG3; bne >6
1441 |1: // Field metatable must be at same offset for GCtab and GCudata!
1442 | lwz TAB:CARG1, TAB:CARG1->metatable
1443 |2:
1444 | li CARG3, LJ_TNIL
1445 | cmplwi TAB:CARG1, 0
1446 | lwz STR:RC, DISPATCH_GL(gcroot[GCROOT_MMNAME+MM_metatable])(DISPATCH)
1447 | beq ->fff_restv
1448 | lwz TMP0, TAB:CARG1->hmask
1449 | li CARG3, LJ_TTAB // Use metatable as default result.
1450 | lwz TMP1, STR:RC->sid
1451 | lwz NODE:TMP2, TAB:CARG1->node
1452 | and TMP1, TMP1, TMP0 // idx = str->sid & tab->hmask
1453 | slwi TMP0, TMP1, 5
1454 | slwi TMP1, TMP1, 3
1455 | sub TMP1, TMP0, TMP1
1456 | add NODE:TMP2, NODE:TMP2, TMP1 // node = tab->node + (idx*32-idx*8)
1457 |3: // Rearranged logic, because we expect _not_ to find the key.
1458 | lwz CARG4, NODE:TMP2->key
1459 | lwz TMP0, 4+offsetof(Node, key)(NODE:TMP2)
1460 | lwz CARG2, NODE:TMP2->val
1461 | lwz TMP1, 4+offsetof(Node, val)(NODE:TMP2)
1462 | checkstr CARG4; bne >4
1463 | cmpw TMP0, STR:RC; beq >5
1464 |4:
1465 | lwz NODE:TMP2, NODE:TMP2->next
1466 | cmplwi NODE:TMP2, 0
1467 | beq ->fff_restv // Not found, keep default result.
1468 | b <3
1469 |5:
1470 | checknil CARG2
1471 | beq ->fff_restv // Ditto for nil value.
1472 | mr CARG3, CARG2 // Return value of mt.__metatable.
1473 | mr CARG1, TMP1
1474 | b ->fff_restv
1475 |
1476 |6:
1477 | cmpwi CARG3, LJ_TUDATA; beq <1
1478 | .gpr64 extsw CARG3, CARG3
1479 | subfc TMP0, TISNUM, CARG3
1480 | subfe TMP2, CARG3, CARG3
1481 | orc TMP1, TMP2, TMP0
1482 | addi TMP1, TMP1, ~LJ_TISNUM+1
1483 | slwi TMP1, TMP1, 2
1484 | la TMP2, DISPATCH_GL(gcroot[GCROOT_BASEMT])(DISPATCH)
1485 | lwzx TAB:CARG1, TMP2, TMP1
1486 | b <2
1487 |
1488 |.ffunc_2 setmetatable
1489 | // Fast path: no mt for table yet and not clearing the mt.
1490 | checktab CARG3; bne ->fff_fallback
1491 | lwz TAB:TMP1, TAB:CARG1->metatable
1492 | checktab CARG4; bne ->fff_fallback
1493 | cmplwi TAB:TMP1, 0
1494 | lbz TMP3, TAB:CARG1->marked
1495 | bne ->fff_fallback
1496 | andix. TMP0, TMP3, LJ_GC_BLACK // isblack(table)
1497 | stw TAB:CARG2, TAB:CARG1->metatable
1498 | beq ->fff_restv
1499 | barrierback TAB:CARG1, TMP3, TMP0
1500 | b ->fff_restv
1501 |
1502 |.ffunc rawget
1503 | cmplwi NARGS8:RC, 16
1504 | lwz CARG4, 0(BASE)
1505 | lwz TAB:CARG2, 4(BASE)
1506 | blt ->fff_fallback
1507 | checktab CARG4; bne ->fff_fallback
1508 | la CARG3, 8(BASE)
1509 | mr CARG1, L
1510 | bl extern lj_tab_get // (lua_State *L, GCtab *t, cTValue *key)
1511 | // Returns cTValue *.
1512 |.if FPU
1513 | lfd FARG1, 0(CRET1)
1514 |.else
1515 | lwz CARG2, 4(CRET1)
1516 | lwz CARG1, 0(CRET1) // Caveat: CARG1 == CRET1.
1517 |.endif
1518 | b ->fff_resn
1519 |
1520 |//-- Base library: conversions ------------------------------------------
1521 |
1522 |.ffunc tonumber
1523 | // Only handles the number case inline (without a base argument).
1524 | cmplwi NARGS8:RC, 8
1525 | lwz CARG1, 0(BASE)
1526 |.if FPU
1527 | lfd FARG1, 0(BASE)
1528 |.else
1529 | lwz CARG2, 4(BASE)
1530 |.endif
1531 | bne ->fff_fallback // Exactly one argument.
1532 | checknum CARG1; bgt ->fff_fallback
1533 | b ->fff_resn
1534 |
1535 |.ffunc_1 tostring
1536 | // Only handles the string or number case inline.
1537 | checkstr CARG3
1538 | // A __tostring method in the string base metatable is ignored.
1539 | beq ->fff_restv // String key?
1540 | // Handle numbers inline, unless a number base metatable is present.
1541 | lwz TMP0, DISPATCH_GL(gcroot[GCROOT_BASEMT_NUM])(DISPATCH)
1542 | checknum CARG3
1543 | cmplwi cr1, TMP0, 0
1544 | stp BASE, L->base // Add frame since C call can throw.
1545 | crorc 4*cr0+eq, 4*cr0+gt, 4*cr1+eq
1546 | stw PC, SAVE_PC // Redundant (but a defined value).
1547 | beq ->fff_fallback
1548 | ffgccheck
1549 | mr CARG1, L
1550 | mr CARG2, BASE
1551 |.if DUALNUM
1552 | bl extern lj_strfmt_number // (lua_State *L, cTValue *o)
1553 |.else
1554 | bl extern lj_strfmt_num // (lua_State *L, lua_Number *np)
1555 |.endif
1556 | // Returns GCstr *.
1557 | li CARG3, LJ_TSTR
1558 | b ->fff_restv
1559 |
1560 |//-- Base library: iterators -------------------------------------------
1561 |
1562 |.ffunc_1 next
1563 | stwx TISNIL, BASE, NARGS8:RC // Set missing 2nd arg to nil.
1564 | checktab CARG3
1565 | lwz PC, FRAME_PC(BASE)
1566 | bne ->fff_fallback
1567 | la CARG2, 8(BASE)
1568 | la CARG3, -8(BASE)
1569 | bl extern lj_tab_next // (GCtab *t, cTValue *key, TValue *o)
1570 | // Returns 1=found, 0=end, -1=error.
1571 | cmpwi CRET1, 0
1572 | la RA, -8(BASE)
1573 | li RD, (2+1)*8
1574 | bgt ->fff_res // Found key/value.
1575 | li CARG3, LJ_TNIL
1576 | beq ->fff_restv // End of traversal: return nil.
1577 | lwz CFUNC:RB, FRAME_FUNC(BASE)
1578 | li NARGS8:RC, 2*8
1579 | b ->fff_fallback // Invalid key.
1580 |
1581 |.ffunc_1 pairs
1582 | checktab CARG3
1583 | lwz PC, FRAME_PC(BASE)
1584 | bne ->fff_fallback
1585 #if LJ_52
1586 | lwz TAB:TMP2, TAB:CARG1->metatable
1587 |.if FPU
1588 | lfd f0, CFUNC:RB->upvalue[0]
1589 |.else
1590 | lwz TMP0, CFUNC:RB->upvalue[0].u32.hi
1591 | lwz TMP1, CFUNC:RB->upvalue[0].u32.lo
1592 |.endif
1593 | cmplwi TAB:TMP2, 0
1594 | la RA, -8(BASE)
1595 | bne ->fff_fallback
1596 #else
1597 |.if FPU
1598 | lfd f0, CFUNC:RB->upvalue[0]
1599 |.else
1600 | lwz TMP0, CFUNC:RB->upvalue[0].u32.hi
1601 | lwz TMP1, CFUNC:RB->upvalue[0].u32.lo
1602 |.endif
1603 | la RA, -8(BASE)
1604 #endif
1605 | stw TISNIL, 8(BASE)
1606 | li RD, (3+1)*8
1607 |.if FPU
1608 | stfd f0, 0(RA)
1609 |.else
1610 | stw TMP0, 0(RA)
1611 | stw TMP1, 4(RA)
1612 |.endif
1613 | b ->fff_res
1614 |
1615 |.ffunc ipairs_aux
1616 | cmplwi NARGS8:RC, 16
1617 | lwz CARG3, 0(BASE)
1618 | lwz TAB:CARG1, 4(BASE)
1619 | lwz CARG4, 8(BASE)
1620 |.if DUALNUM
1621 | lwz TMP2, 12(BASE)
1622 |.else
1623 | lfd FARG2, 8(BASE)
1624 |.endif
1625 | blt ->fff_fallback
1626 | checktab CARG3
1627 | checknum cr1, CARG4
1628 | lwz PC, FRAME_PC(BASE)
1629 |.if DUALNUM
1630 | bne ->fff_fallback
1631 | bne cr1, ->fff_fallback
1632 |.else
1633 | lus TMP0, 0x3ff0
1634 | stw ZERO, TMPD_LO
1635 | bne ->fff_fallback
1636 | stw TMP0, TMPD_HI
1637 | bge cr1, ->fff_fallback
1638 | lfd FARG1, TMPD
1639 | toint TMP2, FARG2, f0
1640 |.endif
1641 | lwz TMP0, TAB:CARG1->asize
1642 | lwz TMP1, TAB:CARG1->array
1643 |.if not DUALNUM
1644 | fadd FARG2, FARG2, FARG1
1645 |.endif
1646 | addi TMP2, TMP2, 1
1647 | la RA, -8(BASE)
1648 | cmplw TMP0, TMP2
1649 |.if DUALNUM
1650 | stw TISNUM, 0(RA)
1651 | slwi TMP3, TMP2, 3
1652 | stw TMP2, 4(RA)
1653 |.else
1654 | slwi TMP3, TMP2, 3
1655 | stfd FARG2, 0(RA)
1656 |.endif
1657 | ble >2 // Not in array part?
1658 |.if FPU
1659 | lwzx TMP2, TMP1, TMP3
1660 | lfdx f0, TMP1, TMP3
1661 |.else
1662 | lwzux TMP2, TMP1, TMP3
1663 | lwz TMP3, 4(TMP1)
1664 |.endif
1665 |1:
1666 | checknil TMP2
1667 | li RD, (0+1)*8
1668 | beq ->fff_res // End of iteration, return 0 results.
1669 | li RD, (2+1)*8
1670 |.if FPU
1671 | stfd f0, 8(RA)
1672 |.else
1673 | stw TMP2, 8(RA)
1674 | stw TMP3, 12(RA)
1675 |.endif
1676 | b ->fff_res
1677 |2: // Check for empty hash part first. Otherwise call C function.
1678 | lwz TMP0, TAB:CARG1->hmask
1679 | cmplwi TMP0, 0
1680 | li RD, (0+1)*8
1681 | beq ->fff_res
1682 | mr CARG2, TMP2
1683 | bl extern lj_tab_getinth // (GCtab *t, int32_t key)
1684 | // Returns cTValue * or NULL.
1685 | cmplwi CRET1, 0
1686 | li RD, (0+1)*8
1687 | beq ->fff_res
1688 | lwz TMP2, 0(CRET1)
1689 |.if FPU
1690 | lfd f0, 0(CRET1)
1691 |.else
1692 | lwz TMP3, 4(CRET1)
1693 |.endif
1694 | b <1
1695 |
1696 |.ffunc_1 ipairs
1697 | checktab CARG3
1698 | lwz PC, FRAME_PC(BASE)
1699 | bne ->fff_fallback
1700 #if LJ_52
1701 | lwz TAB:TMP2, TAB:CARG1->metatable
1702 |.if FPU
1703 | lfd f0, CFUNC:RB->upvalue[0]
1704 |.else
1705 | lwz TMP0, CFUNC:RB->upvalue[0].u32.hi
1706 | lwz TMP1, CFUNC:RB->upvalue[0].u32.lo
1707 |.endif
1708 | cmplwi TAB:TMP2, 0
1709 | la RA, -8(BASE)
1710 | bne ->fff_fallback
1711 #else
1712 |.if FPU
1713 | lfd f0, CFUNC:RB->upvalue[0]
1714 |.else
1715 | lwz TMP0, CFUNC:RB->upvalue[0].u32.hi
1716 | lwz TMP1, CFUNC:RB->upvalue[0].u32.lo
1717 |.endif
1718 | la RA, -8(BASE)
1719 #endif
1720 |.if DUALNUM
1721 | stw TISNUM, 8(BASE)
1722 |.else
1723 | stw ZERO, 8(BASE)
1724 |.endif
1725 | stw ZERO, 12(BASE)
1726 | li RD, (3+1)*8
1727 |.if FPU
1728 | stfd f0, 0(RA)
1729 |.else
1730 | stw TMP0, 0(RA)
1731 | stw TMP1, 4(RA)
1732 |.endif
1733 | b ->fff_res
1734 |
1735 |//-- Base library: catch errors ----------------------------------------
1736 |
1737 |.ffunc pcall
1738 | cmplwi NARGS8:RC, 8
1739 | lbz TMP3, DISPATCH_GL(hookmask)(DISPATCH)
1740 | blt ->fff_fallback
1741 | mr TMP2, BASE
1742 | la BASE, 8(BASE)
1743 | // Remember active hook before pcall.
1744 | rlwinm TMP3, TMP3, 32-HOOK_ACTIVE_SHIFT, 31, 31
1745 | subi NARGS8:RC, NARGS8:RC, 8
1746 | addi PC, TMP3, 8+FRAME_PCALL
1747 | b ->vm_call_dispatch
1748 |
1749 |.ffunc xpcall
1750 | cmplwi NARGS8:RC, 16
1751 | lwz CARG3, 8(BASE)
1752 |.if FPU
1753 | lfd FARG2, 8(BASE)
1754 | lfd FARG1, 0(BASE)
1755 |.else
1756 | lwz CARG1, 0(BASE)
1757 | lwz CARG2, 4(BASE)
1758 | lwz CARG4, 12(BASE)
1759 |.endif
1760 | blt ->fff_fallback
1761 | lbz TMP1, DISPATCH_GL(hookmask)(DISPATCH)
1762 | mr TMP2, BASE
1763 | checkfunc CARG3; bne ->fff_fallback // Traceback must be a function.
1764 | la BASE, 16(BASE)
1765 | // Remember active hook before pcall.
1766 | rlwinm TMP1, TMP1, 32-HOOK_ACTIVE_SHIFT, 31, 31
1767 |.if FPU
1768 | stfd FARG2, 0(TMP2) // Swap function and traceback.
1769 | stfd FARG1, 8(TMP2)
1770 |.else
1771 | stw CARG3, 0(TMP2)
1772 | stw CARG4, 4(TMP2)
1773 | stw CARG1, 8(TMP2)
1774 | stw CARG2, 12(TMP2)
1775 |.endif
1776 | subi NARGS8:RC, NARGS8:RC, 16
1777 | addi PC, TMP1, 16+FRAME_PCALL
1778 | b ->vm_call_dispatch
1779 |
1780 |//-- Coroutine library --------------------------------------------------
1781 |
1782 |.macro coroutine_resume_wrap, resume
1783 |.if resume
1784 |.ffunc_1 coroutine_resume
1785 | cmpwi CARG3, LJ_TTHREAD; bne ->fff_fallback
1786 |.else
1787 |.ffunc coroutine_wrap_aux
1788 | lwz L:CARG1, CFUNC:RB->upvalue[0].gcr
1789 |.endif
1790 | lbz TMP0, L:CARG1->status
1791 | lp TMP1, L:CARG1->cframe
1792 | lp CARG2, L:CARG1->top
1793 | cmplwi cr0, TMP0, LUA_YIELD
1794 | lp TMP2, L:CARG1->base
1795 | cmplwi cr1, TMP1, 0
1796 | lwz TMP0, L:CARG1->maxstack
1797 | cmplw cr7, CARG2, TMP2
1798 | lwz PC, FRAME_PC(BASE)
1799 | crorc 4*cr6+lt, 4*cr0+gt, 4*cr1+eq // st>LUA_YIELD || cframe!=0
1800 | add TMP2, CARG2, NARGS8:RC
1801 | crandc 4*cr6+gt, 4*cr7+eq, 4*cr0+eq // base==top && st!=LUA_YIELD
1802 | cmplw cr1, TMP2, TMP0
1803 | cror 4*cr6+lt, 4*cr6+lt, 4*cr6+gt
1804 | stw PC, SAVE_PC
1805 | cror 4*cr6+lt, 4*cr6+lt, 4*cr1+gt // cond1 || cond2 || stackov
1806 | stp BASE, L->base
1807 | blt cr6, ->fff_fallback
1808 |1:
1809 |.if resume
1810 | addi BASE, BASE, 8 // Keep resumed thread in stack for GC.
1811 | subi NARGS8:RC, NARGS8:RC, 8
1812 | subi TMP2, TMP2, 8
1813 |.endif
1814 | stp TMP2, L:CARG1->top
1815 | li TMP1, 0
1816 | stp BASE, L->top
1817 |2: // Move args to coroutine.
1818 | cmpw TMP1, NARGS8:RC
1819 |.if FPU
1820 | lfdx f0, BASE, TMP1
1821 |.else
1822 | add CARG3, BASE, TMP1
1823 | lwz TMP2, 0(CARG3)
1824 | lwz TMP3, 4(CARG3)
1825 |.endif
1826 | beq >3
1827 |.if FPU
1828 | stfdx f0, CARG2, TMP1
1829 |.else
1830 | add CARG3, CARG2, TMP1
1831 | stw TMP2, 0(CARG3)
1832 | stw TMP3, 4(CARG3)
1833 |.endif
1834 | addi TMP1, TMP1, 8
1835 | b <2
1836 |3:
1837 | li CARG3, 0
1838 | mr L:SAVE0, L:CARG1
1839 | li CARG4, 0
1840 | bl ->vm_resume // (lua_State *L, TValue *base, 0, 0)
1841 | // Returns thread status.
1842 |4:
1843 | lp TMP2, L:SAVE0->base
1844 | cmplwi CRET1, LUA_YIELD
1845 | lp TMP3, L:SAVE0->top
1846 | li_vmstate INTERP
1847 | lp BASE, L->base
1848 | stw L, DISPATCH_GL(cur_L)(DISPATCH)
1849 | st_vmstate
1850 | bgt >8
1851 | sub RD, TMP3, TMP2
1852 | lwz TMP0, L->maxstack
1853 | cmplwi RD, 0
1854 | add TMP1, BASE, RD
1855 | beq >6 // No results?
1856 | cmplw TMP1, TMP0
1857 | li TMP1, 0
1858 | bgt >9 // Need to grow stack?
1859 |
1860 | subi TMP3, RD, 8
1861 | stp TMP2, L:SAVE0->top // Clear coroutine stack.
1862 |5: // Move results from coroutine.
1863 | cmplw TMP1, TMP3
1864 |.if FPU
1865 | lfdx f0, TMP2, TMP1
1866 | stfdx f0, BASE, TMP1
1867 |.else
1868 | add CARG3, TMP2, TMP1
1869 | lwz CARG1, 0(CARG3)
1870 | lwz CARG2, 4(CARG3)
1871 | add CARG3, BASE, TMP1
1872 | stw CARG1, 0(CARG3)
1873 | stw CARG2, 4(CARG3)
1874 |.endif
1875 | addi TMP1, TMP1, 8
1876 | bne <5
1877 |6:
1878 | andix. TMP0, PC, FRAME_TYPE
1879 |.if resume
1880 | li TMP1, LJ_TTRUE
1881 | la RA, -8(BASE)
1882 | stw TMP1, -8(BASE) // Prepend true to results.
1883 | addi RD, RD, 16
1884 |.else
1885 | mr RA, BASE
1886 | addi RD, RD, 8
1887 |.endif
1888 |7:
1889 | stw PC, SAVE_PC
1890 | mr MULTRES, RD
1891 | beq ->BC_RET_Z
1892 | b ->vm_return
1893 |
1894 |8: // Coroutine returned with error (at co->top-1).
1895 |.if resume
1896 | andix. TMP0, PC, FRAME_TYPE
1897 | la TMP3, -8(TMP3)
1898 | li TMP1, LJ_TFALSE
1899 |.if FPU
1900 | lfd f0, 0(TMP3)
1901 |.else
1902 | lwz CARG1, 0(TMP3)
1903 | lwz CARG2, 4(TMP3)
1904 |.endif
1905 | stp TMP3, L:SAVE0->top // Remove error from coroutine stack.
1906 | li RD, (2+1)*8
1907 | stw TMP1, -8(BASE) // Prepend false to results.
1908 | la RA, -8(BASE)
1909 |.if FPU
1910 | stfd f0, 0(BASE) // Copy error message.
1911 |.else
1912 | stw CARG1, 0(BASE) // Copy error message.
1913 | stw CARG2, 4(BASE)
1914 |.endif
1915 | b <7
1916 |.else
1917 | mr CARG1, L
1918 | mr CARG2, L:SAVE0
1919 | bl extern lj_ffh_coroutine_wrap_err // (lua_State *L, lua_State *co)
1920 |.endif
1921 |
1922 |9: // Handle stack expansion on return from yield.
1923 | mr CARG1, L
1924 | srwi CARG2, RD, 3
1925 | bl extern lj_state_growstack // (lua_State *L, int n)
1926 | li CRET1, 0
1927 | b <4
1928 |.endmacro
1929 |
1930 | coroutine_resume_wrap 1 // coroutine.resume
1931 | coroutine_resume_wrap 0 // coroutine.wrap
1932 |
1933 |.ffunc coroutine_yield
1934 | lp TMP0, L->cframe
1935 | add TMP1, BASE, NARGS8:RC
1936 | stp BASE, L->base
1937 | andix. TMP0, TMP0, CFRAME_RESUME
1938 | stp TMP1, L->top
1939 | li CRET1, LUA_YIELD
1940 | beq ->fff_fallback
1941 | stp ZERO, L->cframe
1942 | stb CRET1, L->status
1943 | b ->vm_leave_unw
1944 |
1945 |//-- Math library -------------------------------------------------------
1946 |
1947 |.ffunc_1 math_abs
1948 | checknum CARG3
1949 |.if DUALNUM
1950 | bne >2
1951 | srawi TMP1, CARG1, 31
1952 | xor TMP2, TMP1, CARG1
1953 |.if GPR64
1954 | lus TMP0, 0x8000
1955 | sub CARG1, TMP2, TMP1
1956 | cmplw CARG1, TMP0
1957 | beq >1
1958 |.else
1959 | sub. CARG1, TMP2, TMP1
1960 | blt >1
1961 |.endif
1962 |->fff_resi:
1963 | lwz PC, FRAME_PC(BASE)
1964 | la RA, -8(BASE)
1965 | stw TISNUM, -8(BASE)
1966 | stw CRET1, -4(BASE)
1967 | b ->fff_res1
1968 |1:
1969 | lus CARG3, 0x41e0 // 2^31.
1970 | li CARG1, 0
1971 | b ->fff_restv
1972 |2:
1973 |.endif
1974 | bge ->fff_fallback
1975 | rlwinm CARG3, CARG3, 0, 1, 31
1976 | // Fallthrough.
1977 |
1978 |->fff_restv:
1979 | // CARG3/CARG1 = TValue result.
1980 | lwz PC, FRAME_PC(BASE)
1981 | stw CARG3, -8(BASE)
1982 | la RA, -8(BASE)
1983 | stw CARG1, -4(BASE)
1984 |->fff_res1:
1985 | // RA = results, PC = return.
1986 | li RD, (1+1)*8
1987 |->fff_res:
1988 | // RA = results, RD = (nresults+1)*8, PC = return.
1989 | andix. TMP0, PC, FRAME_TYPE
1990 | mr MULTRES, RD
1991 | bney ->vm_return
1992 | lwz INS, -4(PC)
1993 | decode_RB8 RB, INS
1994 |5:
1995 | cmplw RB, RD // More results expected?
1996 | decode_RA8 TMP0, INS
1997 | bgt >6
1998 | ins_next1
1999 | // Adjust BASE. KBASE is assumed to be set for the calling frame.
2000 | sub BASE, RA, TMP0
2001 | ins_next2
2002 |
2003 |6: // Fill up results with nil.
2004 | subi TMP1, RD, 8
2005 | addi RD, RD, 8
2006 | stwx TISNIL, RA, TMP1
2007 | b <5
2008 |
2009 |.macro math_extern, func
2010 | .ffunc_n math_ .. func
2011 | blex func
2012 | b ->fff_resn
2013 |.endmacro
2014 |
2015 |.macro math_extern2, func
2016 | .ffunc_nn math_ .. func
2017 | blex func
2018 | b ->fff_resn
2019 |.endmacro
2020 |
2021 |.macro math_round, func
2022 | .ffunc_1 math_ .. func
2023 | checknum CARG3; beqy ->fff_restv
2024 | rlwinm TMP2, CARG3, 12, 21, 31
2025 | bge ->fff_fallback
2026 | addic. TMP2, TMP2, -1023 // exp = exponent(x) - 1023
2027 | cmplwi cr1, TMP2, 31 // 0 <= exp < 31?
2028 | subfic TMP0, TMP2, 31
2029 | blt >3
2030 | slwi TMP1, CARG3, 11
2031 | srwi TMP3, CARG1, 21
2032 | oris TMP1, TMP1, 0x8000
2033 | addi TMP2, TMP2, 1
2034 | or TMP1, TMP1, TMP3
2035 | slwi CARG2, CARG1, 11
2036 | bge cr1, >4
2037 | slw TMP3, TMP1, TMP2
2038 | srw RD, TMP1, TMP0
2039 | or TMP3, TMP3, CARG2
2040 | srawi TMP2, CARG3, 31
2041 |.if "func" == "floor"
2042 | and TMP1, TMP3, TMP2
2043 | addic TMP0, TMP1, -1
2044 | subfe TMP1, TMP0, TMP1
2045 | add CARG1, RD, TMP1
2046 | xor CARG1, CARG1, TMP2
2047 | sub CARG1, CARG1, TMP2
2048 | b ->fff_resi
2049 |.else
2050 | andc TMP1, TMP3, TMP2
2051 | addic TMP0, TMP1, -1
2052 | subfe TMP1, TMP0, TMP1
2053 | add CARG1, RD, TMP1
2054 | cmpw CARG1, RD
2055 | xor CARG1, CARG1, TMP2
2056 | sub CARG1, CARG1, TMP2
2057 | bge ->fff_resi
2058 | // Overflow to 2^31.
2059 | lus CARG3, 0x41e0 // 2^31.
2060 | li CARG1, 0
2061 | b ->fff_restv
2062 |.endif
2063 |3: // |x| < 1
2064 | slwi TMP2, CARG3, 1
2065 | srawi TMP1, CARG3, 31
2066 | or TMP2, CARG1, TMP2 // ztest = (hi+hi) | lo
2067 |.if "func" == "floor"
2068 | and TMP1, TMP2, TMP1 // (ztest & sign) == 0 ? 0 : -1
2069 | subfic TMP2, TMP1, 0
2070 | subfe CARG1, CARG1, CARG1
2071 |.else
2072 | andc TMP1, TMP2, TMP1 // (ztest & ~sign) == 0 ? 0 : 1
2073 | addic TMP2, TMP1, -1
2074 | subfe CARG1, TMP2, TMP1
2075 |.endif
2076 | b ->fff_resi
2077 |4: // exp >= 31. Check for -(2^31).
2078 | xoris TMP1, TMP1, 0x8000
2079 | srawi TMP2, CARG3, 31
2080 |.if "func" == "floor"
2081 | or TMP1, TMP1, CARG2
2082 |.endif
2083 |.if PPE
2084 | orc TMP1, TMP1, TMP2
2085 | cmpwi TMP1, 0
2086 |.else
2087 | orc. TMP1, TMP1, TMP2
2088 |.endif
2089 | crand 4*cr0+eq, 4*cr0+eq, 4*cr1+eq
2090 | lus CARG1, 0x8000 // -(2^31).
2091 | beqy ->fff_resi
2092 |5:
2093 |.if FPU
2094 | lfd FARG1, 0(BASE)
2095 |.else
2096 | lwz CARG1, 0(BASE)
2097 | lwz CARG2, 4(BASE)
2098 |.endif
2099 | blex func
2100 | b ->fff_resn
2101 |.endmacro
2102 |
2103 |.if DUALNUM
2104 | math_round floor
2105 | math_round ceil
2106 |.else
2107 | // NYI: use internal implementation.
2108 | math_extern floor
2109 | math_extern ceil
2110 |.endif
2111 |
2112 |.if SQRT
2113 |.ffunc_n math_sqrt
2114 | fsqrt FARG1, FARG1
2115 | b ->fff_resn
2116 |.else
2117 | math_extern sqrt
2118 |.endif
2119 |
2120 |.ffunc math_log
2121 | cmplwi NARGS8:RC, 8
2122 | lwz CARG1, 0(BASE)
2123 | bne ->fff_fallback // Need exactly 1 argument.
2124 | checknum CARG1; bge ->fff_fallback
2125 |.if FPU
2126 | lfd FARG1, 0(BASE)
2127 |.else
2128 | lwz CARG2, 4(BASE)
2129 |.endif
2130 | blex log
2131 | b ->fff_resn
2132 |
2133 | math_extern log10
2134 | math_extern exp
2135 | math_extern sin
2136 | math_extern cos
2137 | math_extern tan
2138 | math_extern asin
2139 | math_extern acos
2140 | math_extern atan
2141 | math_extern sinh
2142 | math_extern cosh
2143 | math_extern tanh
2144 | math_extern2 pow
2145 | math_extern2 atan2
2146 | math_extern2 fmod
2147 |
2148 |.if DUALNUM
2149 |.ffunc math_ldexp
2150 | cmplwi NARGS8:RC, 16
2151 | lwz TMP0, 0(BASE)
2152 |.if FPU
2153 | lfd FARG1, 0(BASE)
2154 |.else
2155 | lwz CARG1, 0(BASE)
2156 | lwz CARG2, 4(BASE)
2157 |.endif
2158 | lwz TMP1, 8(BASE)
2159 |.if GPR64
2160 | lwz CARG2, 12(BASE)
2161 |.elif FPU
2162 | lwz CARG1, 12(BASE)
2163 |.else
2164 | lwz CARG3, 12(BASE)
2165 |.endif
2166 | blt ->fff_fallback
2167 | checknum TMP0; bge ->fff_fallback
2168 | checknum TMP1; bne ->fff_fallback
2169 |.else
2170 |.ffunc_nn math_ldexp
2171 |.if GPR64
2172 | toint CARG2, FARG2
2173 |.else
2174 | toint CARG1, FARG2
2175 |.endif
2176 |.endif
2177 | blex ldexp
2178 | b ->fff_resn
2179 |
2180 |.ffunc_n math_frexp
2181 |.if GPR64
2182 | la CARG2, DISPATCH_GL(tmptv)(DISPATCH)
2183 |.elif FPU
2184 | la CARG1, DISPATCH_GL(tmptv)(DISPATCH)
2185 |.else
2186 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
2187 |.endif
2188 | lwz PC, FRAME_PC(BASE)
2189 | blex frexp
2190 | lwz TMP1, DISPATCH_GL(tmptv)(DISPATCH)
2191 | la RA, -8(BASE)
2192 |.if not DUALNUM
2193 | tonum_i FARG2, TMP1
2194 |.endif
2195 |.if FPU
2196 | stfd FARG1, 0(RA)
2197 |.else
2198 | stw CRET1, 0(RA)
2199 | stw CRET2, 4(RA)
2200 |.endif
2201 | li RD, (2+1)*8
2202 |.if DUALNUM
2203 | stw TISNUM, 8(RA)
2204 | stw TMP1, 12(RA)
2205 |.else
2206 | stfd FARG2, 8(RA)
2207 |.endif
2208 | b ->fff_res
2209 |
2210 |.ffunc_n math_modf
2211 |.if GPR64
2212 | la CARG2, -8(BASE)
2213 |.elif FPU
2214 | la CARG1, -8(BASE)
2215 |.else
2216 | la CARG3, -8(BASE)
2217 |.endif
2218 | lwz PC, FRAME_PC(BASE)
2219 | blex modf
2220 | la RA, -8(BASE)
2221 |.if FPU
2222 | stfd FARG1, 0(BASE)
2223 |.else
2224 | stw CRET1, 0(BASE)
2225 | stw CRET2, 4(BASE)
2226 |.endif
2227 | li RD, (2+1)*8
2228 | b ->fff_res
2229 |
2230 |.macro math_minmax, name, ismax
2231 |.if DUALNUM
2232 | .ffunc_1 name
2233 | checknum CARG3
2234 | addi SAVE0, BASE, 8
2235 | add SAVE1, BASE, NARGS8:RC
2236 | bne >4
2237 |1: // Handle integers.
2238 | lwz CARG4, 0(SAVE0)
2239 | cmplw cr1, SAVE0, SAVE1
2240 | lwz CARG2, 4(SAVE0)
2241 | bge cr1, ->fff_resi
2242 | checknum CARG4
2243 | xoris TMP0, CARG1, 0x8000
2244 | xoris TMP3, CARG2, 0x8000
2245 | bne >3
2246 | subfc TMP3, TMP3, TMP0
2247 | subfe TMP0, TMP0, TMP0
2248 |.if ismax
2249 | andc TMP3, TMP3, TMP0
2250 |.else
2251 | and TMP3, TMP3, TMP0
2252 |.endif
2253 | add CARG1, TMP3, CARG2
2254 |.if GPR64
2255 | rldicl CARG1, CARG1, 0, 32
2256 |.endif
2257 | addi SAVE0, SAVE0, 8
2258 | b <1
2259 |3:
2260 | bge ->fff_fallback
2261 | // Convert intermediate result to number and continue below.
2262 |.if FPU
2263 | tonum_i FARG1, CARG1
2264 | lfd FARG2, 0(SAVE0)
2265 |.else
2266 | mr CARG2, CARG1
2267 | bl ->vm_sfi2d_1
2268 | lwz CARG3, 0(SAVE0)
2269 | lwz CARG4, 4(SAVE0)
2270 |.endif
2271 | b >6
2272 |4:
2273 |.if FPU
2274 | lfd FARG1, 0(BASE)
2275 |.else
2276 | lwz CARG1, 0(BASE)
2277 | lwz CARG2, 4(BASE)
2278 |.endif
2279 | bge ->fff_fallback
2280 |5: // Handle numbers.
2281 | lwz CARG3, 0(SAVE0)
2282 | cmplw cr1, SAVE0, SAVE1
2283 |.if FPU
2284 | lfd FARG2, 0(SAVE0)
2285 |.else
2286 | lwz CARG4, 4(SAVE0)
2287 |.endif
2288 | bge cr1, ->fff_resn
2289 | checknum CARG3; bge >7
2290 |6:
2291 | addi SAVE0, SAVE0, 8
2292 |.if FPU
2293 |.if ismax
2294 | fsub f0, FARG1, FARG2
2295 |.else
2296 | fsub f0, FARG2, FARG1
2297 |.endif
2298 | fsel FARG1, f0, FARG1, FARG2
2299 |.else
2300 | stw CARG1, SFSAVE_1
2301 | stw CARG2, SFSAVE_2
2302 | stw CARG3, SFSAVE_3
2303 | stw CARG4, SFSAVE_4
2304 | blex __ledf2
2305 | cmpwi CRET1, 0
2306 |.if ismax
2307 | blt >8
2308 |.else
2309 | bge >8
2310 |.endif
2311 | lwz CARG1, SFSAVE_1
2312 | lwz CARG2, SFSAVE_2
2313 | b <5
2314 |8:
2315 | lwz CARG1, SFSAVE_3
2316 | lwz CARG2, SFSAVE_4
2317 |.endif
2318 | b <5
2319 |7: // Convert integer to number and continue above.
2320 | lwz CARG3, 4(SAVE0)
2321 | bne ->fff_fallback
2322 |.if FPU
2323 | tonum_i FARG2, CARG3
2324 |.else
2325 | bl ->vm_sfi2d_2
2326 |.endif
2327 | b <6
2328 |.else
2329 | .ffunc_n name
2330 | li TMP1, 8
2331 |1:
2332 | lwzx CARG2, BASE, TMP1
2333 | lfdx FARG2, BASE, TMP1
2334 | cmplw cr1, TMP1, NARGS8:RC
2335 | checknum CARG2
2336 | bge cr1, ->fff_resn
2337 | bge ->fff_fallback
2338 |.if ismax
2339 | fsub f0, FARG1, FARG2
2340 |.else
2341 | fsub f0, FARG2, FARG1
2342 |.endif
2343 | addi TMP1, TMP1, 8
2344 | fsel FARG1, f0, FARG1, FARG2
2345 | b <1
2346 |.endif
2347 |.endmacro
2348 |
2349 | math_minmax math_min, 0
2350 | math_minmax math_max, 1
2351 |
2352 |//-- String library -----------------------------------------------------
2353 |
2354 |.ffunc string_byte // Only handle the 1-arg case here.
2355 | cmplwi NARGS8:RC, 8
2356 | lwz CARG3, 0(BASE)
2357 | lwz STR:CARG1, 4(BASE)
2358 | bne ->fff_fallback // Need exactly 1 argument.
2359 | checkstr CARG3
2360 | bne ->fff_fallback
2361 | lwz TMP0, STR:CARG1->len
2362 |.if DUALNUM
2363 | lbz CARG1, STR:CARG1[1] // Access is always ok (NUL at end).
2364 | li RD, (0+1)*8
2365 | lwz PC, FRAME_PC(BASE)
2366 | cmplwi TMP0, 0
2367 | la RA, -8(BASE)
2368 | beqy ->fff_res
2369 | b ->fff_resi
2370 |.else
2371 | lbz TMP1, STR:CARG1[1] // Access is always ok (NUL at end).
2372 | addic TMP3, TMP0, -1 // RD = ((str->len != 0)+1)*8
2373 | subfe RD, TMP3, TMP0
2374 | stw TMP1, TONUM_LO // Inlined tonum_u f0, TMP1.
2375 | addi RD, RD, 1
2376 | lfd f0, TONUM_D
2377 | la RA, -8(BASE)
2378 | lwz PC, FRAME_PC(BASE)
2379 | fsub f0, f0, TOBIT
2380 | slwi RD, RD, 3
2381 | stfd f0, 0(RA)
2382 | b ->fff_res
2383 |.endif
2384 |
2385 |.ffunc string_char // Only handle the 1-arg case here.
2386 | ffgccheck
2387 | cmplwi NARGS8:RC, 8
2388 | lwz CARG3, 0(BASE)
2389 |.if DUALNUM
2390 | lwz TMP0, 4(BASE)
2391 | bne ->fff_fallback // Exactly 1 argument.
2392 | checknum CARG3; bne ->fff_fallback
2393 | la CARG2, 7(BASE)
2394 |.else
2395 | lfd FARG1, 0(BASE)
2396 | bne ->fff_fallback // Exactly 1 argument.
2397 | checknum CARG3; bge ->fff_fallback
2398 | toint TMP0, FARG1
2399 | la CARG2, TMPD_BLO
2400 |.endif
2401 | li CARG3, 1
2402 | cmplwi TMP0, 255; bgt ->fff_fallback
2403 |->fff_newstr:
2404 | mr CARG1, L
2405 | stp BASE, L->base
2406 | stw PC, SAVE_PC
2407 | bl extern lj_str_new // (lua_State *L, char *str, size_t l)
2408 |->fff_resstr:
2409 | // Returns GCstr *.
2410 | lp BASE, L->base
2411 | li CARG3, LJ_TSTR
2412 | b ->fff_restv
2413 |
2414 |.ffunc string_sub
2415 | ffgccheck
2416 | cmplwi NARGS8:RC, 16
2417 | lwz CARG3, 16(BASE)
2418 |.if not DUALNUM
2419 | lfd f0, 16(BASE)
2420 |.endif
2421 | lwz TMP0, 0(BASE)
2422 | lwz STR:CARG1, 4(BASE)
2423 | blt ->fff_fallback
2424 | lwz CARG2, 8(BASE)
2425 |.if DUALNUM
2426 | lwz TMP1, 12(BASE)
2427 |.else
2428 | lfd f1, 8(BASE)
2429 |.endif
2430 | li TMP2, -1
2431 | beq >1
2432 |.if DUALNUM
2433 | checknum CARG3
2434 | lwz TMP2, 20(BASE)
2435 | bne ->fff_fallback
2436 |1:
2437 | checknum CARG2; bne ->fff_fallback
2438 |.else
2439 | checknum CARG3; bge ->fff_fallback
2440 | toint TMP2, f0
2441 |1:
2442 | checknum CARG2; bge ->fff_fallback
2443 |.endif
2444 | checkstr TMP0; bne ->fff_fallback
2445 |.if not DUALNUM
2446 | toint TMP1, f1
2447 |.endif
2448 | lwz TMP0, STR:CARG1->len
2449 | cmplw TMP0, TMP2 // len < end? (unsigned compare)
2450 | addi TMP3, TMP2, 1
2451 | blt >5
2452 |2:
2453 | cmpwi TMP1, 0 // start <= 0?
2454 | add TMP3, TMP1, TMP0
2455 | ble >7
2456 |3:
2457 | sub CARG3, TMP2, TMP1
2458 | addi CARG2, STR:CARG1, #STR-1
2459 | srawi TMP0, CARG3, 31
2460 | addi CARG3, CARG3, 1
2461 | add CARG2, CARG2, TMP1
2462 | andc CARG3, CARG3, TMP0
2463 |.if GPR64
2464 | rldicl CARG2, CARG2, 0, 32
2465 | rldicl CARG3, CARG3, 0, 32
2466 |.endif
2467 | b ->fff_newstr
2468 |
2469 |5: // Negative end or overflow.
2470 | cmpw TMP0, TMP2 // len >= end? (signed compare)
2471 | add TMP2, TMP0, TMP3 // Negative end: end = end+len+1.
2472 | bge <2
2473 | mr TMP2, TMP0 // Overflow: end = len.
2474 | b <2
2475 |
2476 |7: // Negative start or underflow.
2477 | .gpr64 extsw TMP1, TMP1
2478 | addic CARG3, TMP1, -1
2479 | subfe CARG3, CARG3, CARG3
2480 | srawi CARG2, TMP3, 31 // Note: modifies carry.
2481 | andc TMP3, TMP3, CARG3
2482 | andc TMP1, TMP3, CARG2
2483 | addi TMP1, TMP1, 1 // start = 1 + (start ? start+len : 0)
2484 | b <3
2485 |
2486 |.macro ffstring_op, name
2487 | .ffunc string_ .. name
2488 | ffgccheck
2489 | cmplwi NARGS8:RC, 8
2490 | lwz CARG3, 0(BASE)
2491 | lwz STR:CARG2, 4(BASE)
2492 | blt ->fff_fallback
2493 | checkstr CARG3
2494 | la SBUF:CARG1, DISPATCH_GL(tmpbuf)(DISPATCH)
2495 | bne ->fff_fallback
2496 | lwz TMP0, SBUF:CARG1->b
2497 | stw L, SBUF:CARG1->L
2498 | stp BASE, L->base
2499 | stw PC, SAVE_PC
2500 | stw TMP0, SBUF:CARG1->w
2501 | bl extern lj_buf_putstr_ .. name
2502 | bl extern lj_buf_tostr
2503 | b ->fff_resstr
2504 |.endmacro
2505 |
2506 |ffstring_op reverse
2507 |ffstring_op lower
2508 |ffstring_op upper
2509 |
2510 |//-- Bit library --------------------------------------------------------
2511 |
2512 |.macro .ffunc_bit, name
2513 |.if DUALNUM
2514 | .ffunc_1 bit_..name
2515 | checknum CARG3; bnel ->fff_tobit_fb
2516 |.else
2517 | .ffunc_n bit_..name
2518 | fadd FARG1, FARG1, TOBIT
2519 | stfd FARG1, TMPD
2520 | lwz CARG1, TMPD_LO
2521 |.endif
2522 |.endmacro
2523 |
2524 |.macro .ffunc_bit_op, name, ins
2525 | .ffunc_bit name
2526 | addi SAVE0, BASE, 8
2527 | add SAVE1, BASE, NARGS8:RC
2528 |1:
2529 | lwz CARG4, 0(SAVE0)
2530 | cmplw cr1, SAVE0, SAVE1
2531 |.if DUALNUM
2532 | lwz CARG2, 4(SAVE0)
2533 |.else
2534 | lfd FARG1, 0(SAVE0)
2535 |.endif
2536 | bgey cr1, ->fff_resi
2537 | checknum CARG4
2538 |.if DUALNUM
2539 |.if FPU
2540 | bnel ->fff_bitop_fb
2541 |.else
2542 | beq >3
2543 | stw CARG1, SFSAVE_1
2544 | bl ->fff_bitop_fb
2545 | mr CARG2, CARG1
2546 | lwz CARG1, SFSAVE_1
2547 |3:
2548 |.endif
2549 |.else
2550 | fadd FARG1, FARG1, TOBIT
2551 | bge ->fff_fallback
2552 | stfd FARG1, TMPD
2553 | lwz CARG2, TMPD_LO
2554 |.endif
2555 | ins CARG1, CARG1, CARG2
2556 | addi SAVE0, SAVE0, 8
2557 | b <1
2558 |.endmacro
2559 |
2560 |.ffunc_bit_op band, and
2561 |.ffunc_bit_op bor, or
2562 |.ffunc_bit_op bxor, xor
2563 |
2564 |.ffunc_bit bswap
2565 | rotlwi TMP0, CARG1, 8
2566 | rlwimi TMP0, CARG1, 24, 0, 7
2567 | rlwimi TMP0, CARG1, 24, 16, 23
2568 | mr CRET1, TMP0
2569 | b ->fff_resi
2570 |
2571 |.ffunc_bit bnot
2572 | not CRET1, CARG1
2573 | b ->fff_resi
2574 |
2575 |.macro .ffunc_bit_sh, name, ins, shmod
2576 |.if DUALNUM
2577 | .ffunc_2 bit_..name
2578 |.if FPU
2579 | checknum CARG3; bnel ->fff_tobit_fb
2580 |.else
2581 | checknum CARG3; beq >1
2582 | bl ->fff_tobit_fb
2583 | lwz CARG2, 12(BASE) // Conversion polluted CARG2.
2584 |1:
2585 |.endif
2586 | // Note: no inline conversion from number for 2nd argument!
2587 | checknum CARG4; bne ->fff_fallback
2588 |.else
2589 | .ffunc_nn bit_..name
2590 | fadd FARG1, FARG1, TOBIT
2591 | fadd FARG2, FARG2, TOBIT
2592 | stfd FARG1, TMPD
2593 | lwz CARG1, TMPD_LO
2594 | stfd FARG2, TMPD
2595 | lwz CARG2, TMPD_LO
2596 |.endif
2597 |.if shmod == 1
2598 | rlwinm CARG2, CARG2, 0, 27, 31
2599 |.elif shmod == 2
2600 | neg CARG2, CARG2
2601 |.endif
2602 | ins CRET1, CARG1, CARG2
2603 | b ->fff_resi
2604 |.endmacro
2605 |
2606 |.ffunc_bit_sh lshift, slw, 1
2607 |.ffunc_bit_sh rshift, srw, 1
2608 |.ffunc_bit_sh arshift, sraw, 1
2609 |.ffunc_bit_sh rol, rotlw, 0
2610 |.ffunc_bit_sh ror, rotlw, 2
2611 |
2612 |.ffunc_bit tobit
2613 |.if DUALNUM
2614 | b ->fff_resi
2615 |.else
2616 |->fff_resi:
2617 | tonum_i FARG1, CRET1
2618 |.endif
2619 |->fff_resn:
2620 | lwz PC, FRAME_PC(BASE)
2621 | la RA, -8(BASE)
2622 |.if FPU
2623 | stfd FARG1, -8(BASE)
2624 |.else
2625 | stw CARG1, -8(BASE)
2626 | stw CARG2, -4(BASE)
2627 |.endif
2628 | b ->fff_res1
2629 |
2630 |// Fallback FP number to bit conversion.
2631 |->fff_tobit_fb:
2632 |.if DUALNUM
2633 |.if FPU
2634 | lfd FARG1, 0(BASE)
2635 | bgt ->fff_fallback
2636 | fadd FARG1, FARG1, TOBIT
2637 | stfd FARG1, TMPD
2638 | lwz CARG1, TMPD_LO
2639 | blr
2640 |.else
2641 | bgt ->fff_fallback
2642 | mr CARG2, CARG1
2643 | mr CARG1, CARG3
2644 |// Modifies: CARG1, CARG2, TMP0, TMP1, TMP2.
2645 |->vm_tobit:
2646 | slwi TMP2, CARG1, 1
2647 | addis TMP2, TMP2, 0x0020
2648 | cmpwi TMP2, 0
2649 | bge >2
2650 | li TMP1, 0x3e0
2651 | srawi TMP2, TMP2, 21
2652 | not TMP1, TMP1
2653 | sub. TMP2, TMP1, TMP2
2654 | cmpwi cr7, CARG1, 0
2655 | blt >1
2656 | slwi TMP1, CARG1, 11
2657 | srwi TMP0, CARG2, 21
2658 | oris TMP1, TMP1, 0x8000
2659 | or TMP1, TMP1, TMP0
2660 | srw CARG1, TMP1, TMP2
2661 | bclr 4, 28 // Return if cr7[lt] == 0, no hint.
2662 | neg CARG1, CARG1
2663 | blr
2664 |1:
2665 | addi TMP2, TMP2, 21
2666 | srw TMP1, CARG2, TMP2
2667 | slwi CARG2, CARG1, 12
2668 | subfic TMP2, TMP2, 20
2669 | slw TMP0, CARG2, TMP2
2670 | or CARG1, TMP1, TMP0
2671 | bclr 4, 28 // Return if cr7[lt] == 0, no hint.
2672 | neg CARG1, CARG1
2673 | blr
2674 |2:
2675 | li CARG1, 0
2676 | blr
2677 |.endif
2678 |.endif
2679 |->fff_bitop_fb:
2680 |.if DUALNUM
2681 |.if FPU
2682 | lfd FARG1, 0(SAVE0)
2683 | bgt ->fff_fallback
2684 | fadd FARG1, FARG1, TOBIT
2685 | stfd FARG1, TMPD
2686 | lwz CARG2, TMPD_LO
2687 | blr
2688 |.else
2689 | bgt ->fff_fallback
2690 | mr CARG1, CARG4
2691 | b ->vm_tobit
2692 |.endif
2693 |.endif
2694 |
2695 |//-----------------------------------------------------------------------
2696 |
2697 |->fff_fallback: // Call fast function fallback handler.
2698 | // BASE = new base, RB = CFUNC, RC = nargs*8
2699 | lp TMP3, CFUNC:RB->f
2700 | add TMP1, BASE, NARGS8:RC
2701 | lwz PC, FRAME_PC(BASE) // Fallback may overwrite PC.
2702 | addi TMP0, TMP1, 8*LUA_MINSTACK
2703 | lwz TMP2, L->maxstack
2704 | stw PC, SAVE_PC // Redundant (but a defined value).
2705 | .toc lp TMP3, 0(TMP3)
2706 | cmplw TMP0, TMP2
2707 | stp BASE, L->base
2708 | stp TMP1, L->top
2709 | mr CARG1, L
2710 | bgt >5 // Need to grow stack.
2711 | mtctr TMP3
2712 | bctrl // (lua_State *L)
2713 | // Either throws an error, or recovers and returns -1, 0 or nresults+1.
2714 | lp BASE, L->base
2715 | cmpwi CRET1, 0
2716 | slwi RD, CRET1, 3
2717 | la RA, -8(BASE)
2718 | bgt ->fff_res // Returned nresults+1?
2719 |1: // Returned 0 or -1: retry fast path.
2720 | lp TMP0, L->top
2721 | lwz LFUNC:RB, FRAME_FUNC(BASE)
2722 | sub NARGS8:RC, TMP0, BASE
2723 | bne ->vm_call_tail // Returned -1?
2724 | ins_callt // Returned 0: retry fast path.
2725 |
2726 |// Reconstruct previous base for vmeta_call during tailcall.
2727 |->vm_call_tail:
2728 | andix. TMP0, PC, FRAME_TYPE
2729 | rlwinm TMP1, PC, 0, 0, 28
2730 | bne >3
2731 | lwz INS, -4(PC)
2732 | decode_RA8 TMP1, INS
2733 | addi TMP1, TMP1, 8
2734 |3:
2735 | sub TMP2, BASE, TMP1
2736 | b ->vm_call_dispatch // Resolve again for tailcall.
2737 |
2738 |5: // Grow stack for fallback handler.
2739 | li CARG2, LUA_MINSTACK
2740 | bl extern lj_state_growstack // (lua_State *L, int n)
2741 | lp BASE, L->base
2742 | cmpw TMP0, TMP0 // Set 4*cr0+eq to force retry.
2743 | b <1
2744 |
2745 |->fff_gcstep: // Call GC step function.
2746 | // BASE = new base, RC = nargs*8
2747 | mflr SAVE0
2748 | stp BASE, L->base
2749 | add TMP0, BASE, NARGS8:RC
2750 | stw PC, SAVE_PC // Redundant (but a defined value).
2751 | stp TMP0, L->top
2752 | mr CARG1, L
2753 | bl extern lj_gc_step // (lua_State *L)
2754 | lp BASE, L->base
2755 | mtlr SAVE0
2756 | lp TMP0, L->top
2757 | sub NARGS8:RC, TMP0, BASE
2758 | lwz CFUNC:RB, FRAME_FUNC(BASE)
2759 | blr
2760 |
2761 |//-----------------------------------------------------------------------
2762 |//-- Special dispatch targets -------------------------------------------
2763 |//-----------------------------------------------------------------------
2764 |
2765 |->vm_record: // Dispatch target for recording phase.
2766 |.if JIT
2767 | lbz TMP3, DISPATCH_GL(hookmask)(DISPATCH)
2768 | andix. TMP0, TMP3, HOOK_VMEVENT // No recording while in vmevent.
2769 | bne >5
2770 | // Decrement the hookcount for consistency, but always do the call.
2771 | lwz TMP2, DISPATCH_GL(hookcount)(DISPATCH)
2772 | andix. TMP0, TMP3, HOOK_ACTIVE
2773 | bne >1
2774 | subi TMP2, TMP2, 1
2775 | andi. TMP0, TMP3, LUA_MASKLINE|LUA_MASKCOUNT
2776 | beqy >1
2777 | stw TMP2, DISPATCH_GL(hookcount)(DISPATCH)
2778 | b >1
2779 |.endif
2780 |
2781 |->vm_rethook: // Dispatch target for return hooks.
2782 | lbz TMP3, DISPATCH_GL(hookmask)(DISPATCH)
2783 | andix. TMP0, TMP3, HOOK_ACTIVE // Hook already active?
2784 | beq >1
2785 |5: // Re-dispatch to static ins.
2786 | addi TMP1, TMP1, GG_DISP2STATIC // Assumes decode_OPP TMP1, INS.
2787 | lpx TMP0, DISPATCH, TMP1
2788 | mtctr TMP0
2789 | bctr
2790 |
2791 |->vm_inshook: // Dispatch target for instr/line hooks.
2792 | lbz TMP3, DISPATCH_GL(hookmask)(DISPATCH)
2793 | lwz TMP2, DISPATCH_GL(hookcount)(DISPATCH)
2794 | andix. TMP0, TMP3, HOOK_ACTIVE // Hook already active?
2795 | rlwinm TMP0, TMP3, 31-LUA_HOOKLINE, 31, 0
2796 | bne <5
2797 |
2798 | cmpwi cr1, TMP0, 0
2799 | addic. TMP2, TMP2, -1
2800 | beq cr1, <5
2801 | stw TMP2, DISPATCH_GL(hookcount)(DISPATCH)
2802 | beq >1
2803 | bge cr1, <5
2804 |1:
2805 | mr CARG1, L
2806 | stw MULTRES, SAVE_MULTRES
2807 | mr CARG2, PC
2808 | stp BASE, L->base
2809 | // SAVE_PC must hold the _previous_ PC. The callee updates it with PC.
2810 | bl extern lj_dispatch_ins // (lua_State *L, const BCIns *pc)
2811 |3:
2812 | lp BASE, L->base
2813 |4: // Re-dispatch to static ins.
2814 | lwz INS, -4(PC)
2815 | decode_OPP TMP1, INS
2816 | decode_RB8 RB, INS
2817 | addi TMP1, TMP1, GG_DISP2STATIC
2818 | decode_RD8 RD, INS
2819 | lpx TMP0, DISPATCH, TMP1
2820 | decode_RA8 RA, INS
2821 | decode_RC8 RC, INS
2822 | mtctr TMP0
2823 | bctr
2824 |
2825 |->cont_hook: // Continue from hook yield.
2826 | addi PC, PC, 4
2827 | lwz MULTRES, -20(RB) // Restore MULTRES for *M ins.
2828 | b <4
2829 |
2830 |->vm_hotloop: // Hot loop counter underflow.
2831 |.if JIT
2832 | lwz LFUNC:TMP1, FRAME_FUNC(BASE)
2833 | addi CARG1, DISPATCH, GG_DISP2J
2834 | stw PC, SAVE_PC
2835 | lwz TMP1, LFUNC:TMP1->pc
2836 | mr CARG2, PC
2837 | stw L, DISPATCH_J(L)(DISPATCH)
2838 | lbz TMP1, PC2PROTO(framesize)(TMP1)
2839 | stp BASE, L->base
2840 | slwi TMP1, TMP1, 3
2841 | add TMP1, BASE, TMP1
2842 | stp TMP1, L->top
2843 | bl extern lj_trace_hot // (jit_State *J, const BCIns *pc)
2844 | b <3
2845 |.endif
2846 |
2847 |->vm_callhook: // Dispatch target for call hooks.
2848 | mr CARG2, PC
2849 |.if JIT
2850 | b >1
2851 |.endif
2852 |
2853 |->vm_hotcall: // Hot call counter underflow.
2854 |.if JIT
2855 | ori CARG2, PC, 1
2856 |1:
2857 |.endif
2858 | add TMP0, BASE, RC
2859 | stw PC, SAVE_PC
2860 | mr CARG1, L
2861 | stp BASE, L->base
2862 | sub RA, RA, BASE
2863 | stp TMP0, L->top
2864 | bl extern lj_dispatch_call // (lua_State *L, const BCIns *pc)
2865 | // Returns ASMFunction.
2866 | lp BASE, L->base
2867 | lp TMP0, L->top
2868 | stw ZERO, SAVE_PC // Invalidate for subsequent line hook.
2869 | sub NARGS8:RC, TMP0, BASE
2870 | add RA, BASE, RA
2871 | lwz LFUNC:RB, FRAME_FUNC(BASE)
2872 | lwz INS, -4(PC)
2873 | mtctr CRET1
2874 | bctr
2875 |
2876 |->cont_stitch: // Trace stitching.
2877 |.if JIT
2878 | // RA = resultptr, RB = meta base
2879 | lwz INS, -4(PC)
2880 | lwz TRACE:TMP2, -20(RB) // Save previous trace.
2881 | addic. TMP1, MULTRES, -8
2882 | decode_RA8 RC, INS // Call base.
2883 | beq >2
2884 |1: // Move results down.
2885 |.if FPU
2886 | lfd f0, 0(RA)
2887 |.else
2888 | lwz CARG1, 0(RA)
2889 | lwz CARG2, 4(RA)
2890 |.endif
2891 | addic. TMP1, TMP1, -8
2892 | addi RA, RA, 8
2893 |.if FPU
2894 | stfdx f0, BASE, RC
2895 |.else
2896 | add CARG3, BASE, RC
2897 | stw CARG1, 0(CARG3)
2898 | stw CARG2, 4(CARG3)
2899 |.endif
2900 | addi RC, RC, 8
2901 | bne <1
2902 |2:
2903 | decode_RA8 RA, INS
2904 | decode_RB8 RB, INS
2905 | add RA, RA, RB
2906 |3:
2907 | cmplw RA, RC
2908 | bgt >9 // More results wanted?
2909 |
2910 | lhz TMP3, TRACE:TMP2->traceno
2911 | lhz RD, TRACE:TMP2->link
2912 | cmpw RD, TMP3
2913 | cmpwi cr1, RD, 0
2914 | beq ->cont_nop // Blacklisted.
2915 | slwi RD, RD, 3
2916 | bne cr1, =>BC_JLOOP // Jump to stitched trace.
2917 |
2918 | // Stitch a new trace to the previous trace.
2919 | stw TMP3, DISPATCH_J(exitno)(DISPATCH)
2920 | stp L, DISPATCH_J(L)(DISPATCH)
2921 | stp BASE, L->base
2922 | addi CARG1, DISPATCH, GG_DISP2J
2923 | mr CARG2, PC
2924 | bl extern lj_dispatch_stitch // (jit_State *J, const BCIns *pc)
2925 | lp BASE, L->base
2926 | b ->cont_nop
2927 |
2928 |9:
2929 | stwx TISNIL, BASE, RC
2930 | addi RC, RC, 8
2931 | b <3
2932 |.endif
2933 |
2934 |->vm_profhook: // Dispatch target for profiler hook.
2935 #if LJ_HASPROFILE
2936 | mr CARG1, L
2937 | stw MULTRES, SAVE_MULTRES
2938 | mr CARG2, PC
2939 | stp BASE, L->base
2940 | bl extern lj_dispatch_profile // (lua_State *L, const BCIns *pc)
2941 | // HOOK_PROFILE is off again, so re-dispatch to dynamic instruction.
2942 | lp BASE, L->base
2943 | subi PC, PC, 4
2944 | b ->cont_nop
2945 #endif
2946 |
2947 |//-----------------------------------------------------------------------
2948 |//-- Trace exit handler -------------------------------------------------
2949 |//-----------------------------------------------------------------------
2950 |
2951 |.macro savex_, a, b, c, d
2952 |.if FPU
2953 | stfd f..a, 16+a*8(sp)
2954 | stfd f..b, 16+b*8(sp)
2955 | stfd f..c, 16+c*8(sp)
2956 | stfd f..d, 16+d*8(sp)
2957 |.endif
2958 |.endmacro
2959 |
2960 |->vm_exit_handler:
2961 |.if JIT
2962 | addi sp, sp, -(16+32*8+32*4)
2963 | stmw r2, 16+32*8+2*4(sp)
2964 | addi DISPATCH, JGL, -GG_DISP2G-32768
2965 | li CARG2, ~LJ_VMST_EXIT
2966 | lwz CARG1, 16+32*8+32*4(sp) // Get stack chain.
2967 | stw CARG2, DISPATCH_GL(vmstate)(DISPATCH)
2968 | savex_ 0,1,2,3
2969 | stw CARG1, 0(sp) // Store extended stack chain.
2970 | clrso TMP1
2971 | savex_ 4,5,6,7
2972 | addi CARG2, sp, 16+32*8+32*4 // Recompute original value of sp.
2973 | savex_ 8,9,10,11
2974 | stw CARG2, 16+32*8+1*4(sp) // Store sp in RID_SP.
2975 | savex_ 12,13,14,15
2976 | mflr CARG3
2977 | li TMP1, 0
2978 | savex_ 16,17,18,19
2979 | stw TMP1, 16+32*8+0*4(sp) // Clear RID_TMP.
2980 | savex_ 20,21,22,23
2981 | lhz CARG4, 2(CARG3) // Load trace number.
2982 | savex_ 24,25,26,27
2983 | lwz L, DISPATCH_GL(cur_L)(DISPATCH)
2984 | savex_ 28,29,30,31
2985 | sub CARG3, TMP0, CARG3 // Compute exit number.
2986 | lp BASE, DISPATCH_GL(jit_base)(DISPATCH)
2987 | srwi CARG3, CARG3, 2
2988 | stp L, DISPATCH_J(L)(DISPATCH)
2989 | subi CARG3, CARG3, 2
2990 | stp BASE, L->base
2991 | stw CARG4, DISPATCH_J(parent)(DISPATCH)
2992 | stw TMP1, DISPATCH_GL(jit_base)(DISPATCH)
2993 | addi CARG1, DISPATCH, GG_DISP2J
2994 | stw CARG3, DISPATCH_J(exitno)(DISPATCH)
2995 | addi CARG2, sp, 16
2996 | bl extern lj_trace_exit // (jit_State *J, ExitState *ex)
2997 | // Returns MULTRES (unscaled) or negated error code.
2998 | lp TMP1, L->cframe
2999 | lwz TMP2, 0(sp)
3000 | lp BASE, L->base
3001 |.if GPR64
3002 | rldicr sp, TMP1, 0, 61
3003 |.else
3004 | rlwinm sp, TMP1, 0, 0, 29
3005 |.endif
3006 | lwz PC, SAVE_PC // Get SAVE_PC.
3007 | stw TMP2, 0(sp)
3008 | stw L, SAVE_L // Set SAVE_L (on-trace resume/yield).
3009 | b >1
3010 |.endif
3011 |->vm_exit_interp:
3012 |.if JIT
3013 | // CARG1 = MULTRES or negated error code, BASE, PC and JGL set.
3014 | lwz L, SAVE_L
3015 | addi DISPATCH, JGL, -GG_DISP2G-32768
3016 | stp BASE, L->base
3017 |1:
3018 | li TMP2, -LUA_ERRERR
3019 | cmplw CARG1, TMP2
3020 | bge >9 // Check for error from exit.
3021 | lwz LFUNC:RB, FRAME_FUNC(BASE)
3022 | slwi MULTRES, CARG1, 3
3023 | li TMP2, 0
3024 | stw MULTRES, SAVE_MULTRES
3025 | lwz TMP1, LFUNC:RB->pc
3026 | stw TMP2, DISPATCH_GL(jit_base)(DISPATCH)
3027 | lwz KBASE, PC2PROTO(k)(TMP1)
3028 | // Setup type comparison constants.
3029 | li TISNUM, LJ_TISNUM
3030 | .FPU lus TMP3, 0x59c0 // TOBIT = 2^52 + 2^51 (float).
3031 | .FPU stw TMP3, TMPD
3032 | li ZERO, 0
3033 | .FPU ori TMP3, TMP3, 0x0004 // TONUM = 2^52 + 2^51 + 2^31 (float).
3034 | .FPU lfs TOBIT, TMPD
3035 | .FPU stw TMP3, TMPD
3036 | .FPU lus TMP0, 0x4338 // Hiword of 2^52 + 2^51 (double)
3037 | li TISNIL, LJ_TNIL
3038 | .FPU stw TMP0, TONUM_HI
3039 | .FPU lfs TONUM, TMPD
3040 | // Modified copy of ins_next which handles function header dispatch, too.
3041 | lwz INS, 0(PC)
3042 | addi PC, PC, 4
3043 | // Assumes TISNIL == ~LJ_VMST_INTERP == -1.
3044 | stw TISNIL, DISPATCH_GL(vmstate)(DISPATCH)
3045 | cmpwi CARG1, -17 // Static dispatch?
3046 | beq >5
3047 | decode_OPP TMP1, INS
3048 | decode_RA8 RA, INS
3049 | lpx TMP0, DISPATCH, TMP1
3050 | mtctr TMP0
3051 | cmplwi TMP1, BC_FUNCF*4 // Function header?
3052 | bge >2
3053 | decode_RB8 RB, INS
3054 | decode_RD8 RD, INS
3055 | decode_RC8 RC, INS
3056 | bctr
3057 |2:
3058 | cmplwi TMP1, (BC_FUNCC+2)*4 // Fast function?
3059 | blt >3
3060 | // Check frame below fast function.
3061 | lwz TMP1, FRAME_PC(BASE)
3062 | andix. TMP0, TMP1, FRAME_TYPE
3063 | bney >3 // Trace stitching continuation?
3064 | // Otherwise set KBASE for Lua function below fast function.
3065 | lwz TMP2, -4(TMP1)
3066 | decode_RA8 TMP0, TMP2
3067 | sub TMP1, BASE, TMP0
3068 | lwz LFUNC:TMP2, -12(TMP1)
3069 | lwz TMP1, LFUNC:TMP2->pc
3070 | lwz KBASE, PC2PROTO(k)(TMP1)
3071 |3:
3072 | subi RC, MULTRES, 8
3073 | add RA, RA, BASE
3074 | bctr
3075 |
3076 |5: // Dispatch to static entry of original ins replaced by BC_JLOOP.
3077 | lwz TMP1, DISPATCH_J(trace)(DISPATCH)
3078 | decode_RD4 RD, INS
3079 | lwzx TRACE:TMP1, TMP1, RD
3080 | lwz INS, TRACE:TMP1->startins
3081 | decode_OPP TMP1, INS
3082 | addi TMP1, TMP1, GG_DISP2STATIC
3083 | lpx TMP0, DISPATCH, TMP1
3084 | mtctr TMP0
3085 | decode_RB8 RB, INS
3086 | decode_RD8 RD, INS
3087 | decode_RA8 RA, INS
3088 | decode_RC8 RC, INS
3089 | bctr
3090 |
3091 |9: // Rethrow error from the right C frame.
3092 | neg CARG2, CARG1
3093 | mr CARG1, L
3094 | bl extern lj_err_trace // (lua_State *L, int errcode)
3095 |.endif
3096 |
3097 |//-----------------------------------------------------------------------
3098 |//-- Math helper functions ----------------------------------------------
3099 |//-----------------------------------------------------------------------
3100 |
3101 |// NYI: Use internal implementations of floor, ceil, trunc, sfcmp.
3102 |
3103 |.macro sfi2d, AHI, ALO
3104 |.if not FPU
3105 | mr. AHI, ALO
3106 | bclr 12, 2 // Handle zero first.
3107 | srawi TMP0, ALO, 31
3108 | xor TMP1, ALO, TMP0
3109 | sub TMP1, TMP1, TMP0 // Absolute value in TMP1.
3110 | cntlzw AHI, TMP1
3111 | andix. TMP0, TMP0, 0x800 // Mask sign bit.
3112 | slw TMP1, TMP1, AHI // Align mantissa left with leading 1.
3113 | subfic AHI, AHI, 0x3ff+31-1 // Exponent -1 in AHI.
3114 | slwi ALO, TMP1, 21
3115 | or AHI, AHI, TMP0 // Sign | Exponent.
3116 | srwi TMP1, TMP1, 11
3117 | slwi AHI, AHI, 20 // Align left.
3118 | add AHI, AHI, TMP1 // Add mantissa, increment exponent.
3119 | blr
3120 |.endif
3121 |.endmacro
3122 |
3123 |// Input: CARG2. Output: CARG1, CARG2. Temporaries: TMP0, TMP1.
3124 |->vm_sfi2d_1:
3125 | sfi2d CARG1, CARG2
3126 |
3127 |// Input: CARG4. Output: CARG3, CARG4. Temporaries: TMP0, TMP1.
3128 |->vm_sfi2d_2:
3129 | sfi2d CARG3, CARG4
3130 |
3131 |->vm_modi:
3132 | divwo. TMP0, CARG1, CARG2
3133 | bso >1
3134 |.if GPR64
3135 | xor CARG3, CARG1, CARG2
3136 | cmpwi CARG3, 0
3137 |.else
3138 | xor. CARG3, CARG1, CARG2
3139 |.endif
3140 | mullw TMP0, TMP0, CARG2
3141 | sub CARG1, CARG1, TMP0
3142 | bgelr
3143 | cmpwi CARG1, 0; beqlr
3144 | add CARG1, CARG1, CARG2
3145 | blr
3146 |1:
3147 | cmpwi CARG2, 0
3148 | li CARG1, 0
3149 | beqlr
3150 | clrso TMP0 // Clear SO for -2147483648 % -1 and return 0.
3151 | blr
3152 |
3153 |//-----------------------------------------------------------------------
3154 |//-- Miscellaneous functions --------------------------------------------
3155 |//-----------------------------------------------------------------------
3156 |
3157 |// void lj_vm_cachesync(void *start, void *end)
3158 |// Flush D-Cache and invalidate I-Cache. Assumes 32 byte cache line size.
3159 |// This is a good lower bound, except for very ancient PPC models.
3160 |->vm_cachesync:
3161 |.if JIT or FFI
3162 | // Compute start of first cache line and number of cache lines.
3163 | rlwinm CARG1, CARG1, 0, 0, 26
3164 | sub CARG2, CARG2, CARG1
3165 | addi CARG2, CARG2, 31
3166 | rlwinm. CARG2, CARG2, 27, 5, 31
3167 | beqlr
3168 | mtctr CARG2
3169 | mr CARG3, CARG1
3170 |1: // Flush D-Cache.
3171 | dcbst r0, CARG1
3172 | addi CARG1, CARG1, 32
3173 | bdnz <1
3174 | sync
3175 | mtctr CARG2
3176 |1: // Invalidate I-Cache.
3177 | icbi r0, CARG3
3178 | addi CARG3, CARG3, 32
3179 | bdnz <1
3180 | isync
3181 | blr
3182 |.endif
3183 |
3184 |->vm_next:
3185 |.if JIT
3186 | NYI // On big-endian.
3187 |.endif
3188 |
3189 |//-----------------------------------------------------------------------
3190 |//-- FFI helper functions -----------------------------------------------
3191 |//-----------------------------------------------------------------------
3192 |
3193 |// Handler for callback functions. Callback slot number in r11, g in r12.
3194 |->vm_ffi_callback:
3195 |.if FFI
3196 |.type CTSTATE, CTState, PC
3197 | saveregs
3198 | lwz CTSTATE, GL:r12->ctype_state
3199 | addi DISPATCH, r12, GG_G2DISP
3200 | stw r11, CTSTATE->cb.slot
3201 | stw r3, CTSTATE->cb.gpr[0]
3202 | .FPU stfd f1, CTSTATE->cb.fpr[0]
3203 | stw r4, CTSTATE->cb.gpr[1]
3204 | .FPU stfd f2, CTSTATE->cb.fpr[1]
3205 | stw r5, CTSTATE->cb.gpr[2]
3206 | .FPU stfd f3, CTSTATE->cb.fpr[2]
3207 | stw r6, CTSTATE->cb.gpr[3]
3208 | .FPU stfd f4, CTSTATE->cb.fpr[3]
3209 | stw r7, CTSTATE->cb.gpr[4]
3210 | .FPU stfd f5, CTSTATE->cb.fpr[4]
3211 | stw r8, CTSTATE->cb.gpr[5]
3212 | .FPU stfd f6, CTSTATE->cb.fpr[5]
3213 | stw r9, CTSTATE->cb.gpr[6]
3214 | .FPU stfd f7, CTSTATE->cb.fpr[6]
3215 | stw r10, CTSTATE->cb.gpr[7]
3216 | .FPU stfd f8, CTSTATE->cb.fpr[7]
3217 | addi TMP0, sp, CFRAME_SPACE+8
3218 | stw TMP0, CTSTATE->cb.stack
3219 | mr CARG1, CTSTATE
3220 | stw CTSTATE, SAVE_PC // Any value outside of bytecode is ok.
3221 | mr CARG2, sp
3222 | bl extern lj_ccallback_enter // (CTState *cts, void *cf)
3223 | // Returns lua_State *.
3224 | lp BASE, L:CRET1->base
3225 | li TISNUM, LJ_TISNUM // Setup type comparison constants.
3226 | lp RC, L:CRET1->top
3227 | .FPU lus TMP3, 0x59c0 // TOBIT = 2^52 + 2^51 (float).
3228 | li ZERO, 0
3229 | mr L, CRET1
3230 | .FPU stw TMP3, TMPD
3231 | .FPU lus TMP0, 0x4338 // Hiword of 2^52 + 2^51 (double)
3232 | lwz LFUNC:RB, FRAME_FUNC(BASE)
3233 | .FPU ori TMP3, TMP3, 0x0004 // TONUM = 2^52 + 2^51 + 2^31 (float).
3234 | .FPU stw TMP0, TONUM_HI
3235 | li TISNIL, LJ_TNIL
3236 | li_vmstate INTERP
3237 | .FPU lfs TOBIT, TMPD
3238 | .FPU stw TMP3, TMPD
3239 | sub RC, RC, BASE
3240 | st_vmstate
3241 | .FPU lfs TONUM, TMPD
3242 | ins_callt
3243 |.endif
3244 |
3245 |->cont_ffi_callback: // Return from FFI callback.
3246 |.if FFI
3247 | lwz CTSTATE, DISPATCH_GL(ctype_state)(DISPATCH)
3248 | stp BASE, L->base
3249 | stp RB, L->top
3250 | stp L, CTSTATE->L
3251 | mr CARG1, CTSTATE
3252 | mr CARG2, RA
3253 | bl extern lj_ccallback_leave // (CTState *cts, TValue *o)
3254 | lwz CRET1, CTSTATE->cb.gpr[0]
3255 | .FPU lfd FARG1, CTSTATE->cb.fpr[0]
3256 | lwz CRET2, CTSTATE->cb.gpr[1]
3257 | b ->vm_leave_unw
3258 |.endif
3259 |
3260 |->vm_ffi_call: // Call C function via FFI.
3261 | // Caveat: needs special frame unwinding, see below.
3262 |.if FFI
3263 | .type CCSTATE, CCallState, CARG1
3264 | lwz TMP1, CCSTATE->spadj
3265 | mflr TMP0
3266 | lbz CARG2, CCSTATE->nsp
3267 | lbz CARG3, CCSTATE->nfpr
3268 | neg TMP1, TMP1
3269 | stw TMP0, 4(sp)
3270 | cmpwi cr1, CARG3, 0
3271 | mr TMP2, sp
3272 | addic. CARG2, CARG2, -1
3273 | stwux sp, sp, TMP1
3274 | crnot 4*cr1+eq, 4*cr1+eq // For vararg calls.
3275 | stw r14, -4(TMP2)
3276 | stw CCSTATE, -8(TMP2)
3277 | mr r14, TMP2
3278 | la TMP1, CCSTATE->stack
3279 | slwi CARG2, CARG2, 2
3280 | blty >2
3281 | la TMP2, 8(sp)
3282 |1:
3283 | lwzx TMP0, TMP1, CARG2
3284 | stwx TMP0, TMP2, CARG2
3285 | addic. CARG2, CARG2, -4
3286 | bge <1
3287 |2:
3288 | bney cr1, >3
3289 | .FPU lfd f1, CCSTATE->fpr[0]
3290 | .FPU lfd f2, CCSTATE->fpr[1]
3291 | .FPU lfd f3, CCSTATE->fpr[2]
3292 | .FPU lfd f4, CCSTATE->fpr[3]
3293 | .FPU lfd f5, CCSTATE->fpr[4]
3294 | .FPU lfd f6, CCSTATE->fpr[5]
3295 | .FPU lfd f7, CCSTATE->fpr[6]
3296 | .FPU lfd f8, CCSTATE->fpr[7]
3297 |3:
3298 | lp TMP0, CCSTATE->func
3299 | lwz CARG2, CCSTATE->gpr[1]
3300 | lwz CARG3, CCSTATE->gpr[2]
3301 | lwz CARG4, CCSTATE->gpr[3]
3302 | lwz CARG5, CCSTATE->gpr[4]
3303 | mtctr TMP0
3304 | lwz r8, CCSTATE->gpr[5]
3305 | lwz r9, CCSTATE->gpr[6]
3306 | lwz r10, CCSTATE->gpr[7]
3307 | lwz CARG1, CCSTATE->gpr[0] // Do this last, since CCSTATE is CARG1.
3308 | bctrl
3309 | lwz CCSTATE:TMP1, -8(r14)
3310 | lwz TMP2, -4(r14)
3311 | lwz TMP0, 4(r14)
3312 | stw CARG1, CCSTATE:TMP1->gpr[0]
3313 | .FPU stfd FARG1, CCSTATE:TMP1->fpr[0]
3314 | stw CARG2, CCSTATE:TMP1->gpr[1]
3315 | mtlr TMP0
3316 | stw CARG3, CCSTATE:TMP1->gpr[2]
3317 | mr sp, r14
3318 | stw CARG4, CCSTATE:TMP1->gpr[3]
3319 | mr r14, TMP2
3320 | blr
3321 |.endif
3322 |// Note: vm_ffi_call must be the last function in this object file!
3323 |
3324 |//-----------------------------------------------------------------------
3325 }
3326
3327 /* Generate the code for a single instruction. */
3328 static void build_ins(BuildCtx *ctx, BCOp op, int defop)
3329 {
3330 int vk = 0;
3331 |=>defop:
3332
3333 switch (op) {
3334
3335 /* -- Comparison ops ---------------------------------------------------- */
3336
3337 /* Remember: all ops branch for a true comparison, fall through otherwise. */
3338
3339 case BC_ISLT: case BC_ISGE: case BC_ISLE: case BC_ISGT:
3340 | // RA = src1*8, RD = src2*8, JMP with RD = target
3341 |.if DUALNUM
3342 | lwzux CARG1, RA, BASE
3343 | addi PC, PC, 4
3344 | lwz CARG2, 4(RA)
3345 | lwzux CARG3, RD, BASE
3346 | lwz TMP2, -4(PC)
3347 | checknum cr0, CARG1
3348 | lwz CARG4, 4(RD)
3349 | decode_RD4 TMP2, TMP2
3350 | checknum cr1, CARG3
3351 | addis SAVE0, TMP2, -(BCBIAS_J*4 >> 16)
3352 | bne cr0, >7
3353 | bne cr1, >8
3354 | cmpw CARG2, CARG4
3355 if (op == BC_ISLT) {
3356 | bge >2
3357 } else if (op == BC_ISGE) {
3358 | blt >2
3359 } else if (op == BC_ISLE) {
3360 | bgt >2
3361 } else {
3362 | ble >2
3363 }
3364 |1:
3365 | add PC, PC, SAVE0
3366 |2:
3367 | ins_next
3368 |
3369 |7: // RA is not an integer.
3370 | bgt cr0, ->vmeta_comp
3371 | // RA is a number.
3372 | .FPU lfd f0, 0(RA)
3373 | bgt cr1, ->vmeta_comp
3374 | blt cr1, >4
3375 | // RA is a number, RD is an integer.
3376 |.if FPU
3377 | tonum_i f1, CARG4
3378 |.else
3379 | bl ->vm_sfi2d_2
3380 |.endif
3381 | b >5
3382 |
3383 |8: // RA is an integer, RD is not an integer.
3384 | bgt cr1, ->vmeta_comp
3385 | // RA is an integer, RD is a number.
3386 |.if FPU
3387 | tonum_i f0, CARG2
3388 |.else
3389 | bl ->vm_sfi2d_1
3390 |.endif
3391 |4:
3392 | .FPU lfd f1, 0(RD)
3393 |5:
3394 |.if FPU
3395 | fcmpu cr0, f0, f1
3396 |.else
3397 | blex __ledf2
3398 | cmpwi CRET1, 0
3399 |.endif
3400 if (op == BC_ISLT) {
3401 | bge <2
3402 } else if (op == BC_ISGE) {
3403 | blt <2
3404 } else if (op == BC_ISLE) {
3405 | cror 4*cr0+lt, 4*cr0+lt, 4*cr0+eq
3406 | bge <2
3407 } else {
3408 | cror 4*cr0+lt, 4*cr0+lt, 4*cr0+eq
3409 | blt <2
3410 }
3411 | b <1
3412 |.else
3413 | lwzx TMP0, BASE, RA
3414 | addi PC, PC, 4
3415 | lfdx f0, BASE, RA
3416 | lwzx TMP1, BASE, RD
3417 | checknum cr0, TMP0
3418 | lwz TMP2, -4(PC)
3419 | lfdx f1, BASE, RD
3420 | checknum cr1, TMP1
3421 | decode_RD4 TMP2, TMP2
3422 | bge cr0, ->vmeta_comp
3423 | addis TMP2, TMP2, -(BCBIAS_J*4 >> 16)
3424 | bge cr1, ->vmeta_comp
3425 | fcmpu cr0, f0, f1
3426 if (op == BC_ISLT) {
3427 | bge >1
3428 } else if (op == BC_ISGE) {
3429 | blt >1
3430 } else if (op == BC_ISLE) {
3431 | cror 4*cr0+lt, 4*cr0+lt, 4*cr0+eq
3432 | bge >1
3433 } else {
3434 | cror 4*cr0+lt, 4*cr0+lt, 4*cr0+eq
3435 | blt >1
3436 }
3437 | add PC, PC, TMP2
3438 |1:
3439 | ins_next
3440 |.endif
3441 break;
3442
3443 case BC_ISEQV: case BC_ISNEV:
3444 vk = op == BC_ISEQV;
3445 | // RA = src1*8, RD = src2*8, JMP with RD = target
3446 |.if DUALNUM
3447 | lwzux CARG1, RA, BASE
3448 | addi PC, PC, 4
3449 | lwz CARG2, 4(RA)
3450 | lwzux CARG3, RD, BASE
3451 | checknum cr0, CARG1
3452 | lwz SAVE0, -4(PC)
3453 | checknum cr1, CARG3
3454 | decode_RD4 SAVE0, SAVE0
3455 | lwz CARG4, 4(RD)
3456 | cror 4*cr7+gt, 4*cr0+gt, 4*cr1+gt
3457 | addis SAVE0, SAVE0, -(BCBIAS_J*4 >> 16)
3458 if (vk) {
3459 | ble cr7, ->BC_ISEQN_Z
3460 } else {
3461 | ble cr7, ->BC_ISNEN_Z
3462 }
3463 |.else
3464 | lwzux CARG1, RA, BASE
3465 | lwz SAVE0, 0(PC)
3466 | lfd f0, 0(RA)
3467 | addi PC, PC, 4
3468 | lwzux CARG3, RD, BASE
3469 | checknum cr0, CARG1
3470 | decode_RD4 SAVE0, SAVE0
3471 | lfd f1, 0(RD)
3472 | checknum cr1, CARG3
3473 | addis SAVE0, SAVE0, -(BCBIAS_J*4 >> 16)
3474 | bge cr0, >5
3475 | bge cr1, >5
3476 | fcmpu cr0, f0, f1
3477 if (vk) {
3478 | bne >1
3479 | add PC, PC, SAVE0
3480 } else {
3481 | beq >1
3482 | add PC, PC, SAVE0
3483 }
3484 |1:
3485 | ins_next
3486 |.endif
3487 |5: // Either or both types are not numbers.
3488 |.if not DUALNUM
3489 | lwz CARG2, 4(RA)
3490 | lwz CARG4, 4(RD)
3491 |.endif
3492 |.if FFI
3493 | cmpwi cr7, CARG1, LJ_TCDATA
3494 | cmpwi cr5, CARG3, LJ_TCDATA
3495 |.endif
3496 | not TMP2, CARG1
3497 | cmplw CARG1, CARG3
3498 | cmplwi cr1, TMP2, ~LJ_TISPRI // Primitive?
3499 |.if FFI
3500 | cror 4*cr7+eq, 4*cr7+eq, 4*cr5+eq
3501 |.endif
3502 | cmplwi cr6, TMP2, ~LJ_TISTABUD // Table or userdata?
3503 |.if FFI
3504 | beq cr7, ->vmeta_equal_cd
3505 |.endif
3506 | cmplw cr5, CARG2, CARG4
3507 | crandc 4*cr0+gt, 4*cr0+eq, 4*cr1+gt // 2: Same type and primitive.
3508 | crorc 4*cr0+lt, 4*cr5+eq, 4*cr0+eq // 1: Same tv or different type.
3509 | crand 4*cr0+eq, 4*cr0+eq, 4*cr5+eq // 0: Same type and same tv.
3510 | mr SAVE1, PC
3511 | cror 4*cr0+eq, 4*cr0+eq, 4*cr0+gt // 0 or 2.
3512 | cror 4*cr0+lt, 4*cr0+lt, 4*cr0+gt // 1 or 2.
3513 if (vk) {
3514 | bne cr0, >6
3515 | add PC, PC, SAVE0
3516 |6:
3517 } else {
3518 | beq cr0, >6
3519 | add PC, PC, SAVE0
3520 |6:
3521 }
3522 |.if DUALNUM
3523 | bge cr0, >2 // Done if 1 or 2.
3524 |1:
3525 | ins_next
3526 |2:
3527 |.else
3528 | blt cr0, <1 // Done if 1 or 2.
3529 |.endif
3530 | blt cr6, <1 // Done if not tab/ud.
3531 |
3532 | // Different tables or userdatas. Need to check __eq metamethod.
3533 | // Field metatable must be at same offset for GCtab and GCudata!
3534 | mr CARG3, CARG4
3535 | lwz TAB:TMP2, TAB:CARG2->metatable
3536 | li CARG4, 1-vk // ne = 0 or 1.
3537 | cmplwi TAB:TMP2, 0
3538 | beq <1 // No metatable?
3539 | lbz TMP2, TAB:TMP2->nomm
3540 | andix. TMP2, TMP2, 1<<MM_eq
3541 | bne <1 // Or 'no __eq' flag set?
3542 | mr PC, SAVE1 // Restore old PC.
3543 | b ->vmeta_equal // Handle __eq metamethod.
3544 break;
3545
3546 case BC_ISEQS: case BC_ISNES:
3547 vk = op == BC_ISEQS;
3548 | // RA = src*8, RD = str_const*8 (~), JMP with RD = target
3549 | lwzux TMP0, RA, BASE
3550 | srwi RD, RD, 1
3551 | lwz STR:TMP3, 4(RA)
3552 | lwz TMP2, 0(PC)
3553 | subfic RD, RD, -4
3554 | addi PC, PC, 4
3555 |.if FFI
3556 | cmpwi TMP0, LJ_TCDATA
3557 |.endif
3558 | lwzx STR:TMP1, KBASE, RD // KBASE-4-str_const*4
3559 | .gpr64 extsw TMP0, TMP0
3560 | subfic TMP0, TMP0, LJ_TSTR
3561 |.if FFI
3562 | beq ->vmeta_equal_cd
3563 |.endif
3564 | sub TMP1, STR:TMP1, STR:TMP3
3565 | or TMP0, TMP0, TMP1
3566 | decode_RD4 TMP2, TMP2
3567 | subfic TMP0, TMP0, 0
3568 | addis TMP2, TMP2, -(BCBIAS_J*4 >> 16)
3569 | subfe TMP1, TMP1, TMP1
3570 if (vk) {
3571 | andc TMP2, TMP2, TMP1
3572 } else {
3573 | and TMP2, TMP2, TMP1
3574 }
3575 | add PC, PC, TMP2
3576 | ins_next
3577 break;
3578
3579 case BC_ISEQN: case BC_ISNEN:
3580 vk = op == BC_ISEQN;
3581 | // RA = src*8, RD = num_const*8, JMP with RD = target
3582 |.if DUALNUM
3583 | lwzux CARG1, RA, BASE
3584 | addi PC, PC, 4
3585 | lwz CARG2, 4(RA)
3586 | lwzux CARG3, RD, KBASE
3587 | checknum cr0, CARG1
3588 | lwz SAVE0, -4(PC)
3589 | checknum cr1, CARG3
3590 | decode_RD4 SAVE0, SAVE0
3591 | lwz CARG4, 4(RD)
3592 | addis SAVE0, SAVE0, -(BCBIAS_J*4 >> 16)
3593 if (vk) {
3594 |->BC_ISEQN_Z:
3595 } else {
3596 |->BC_ISNEN_Z:
3597 }
3598 | bne cr0, >7
3599 | bne cr1, >8
3600 | cmpw CARG2, CARG4
3601 |4:
3602 |.else
3603 if (vk) {
3604 |->BC_ISEQN_Z: // Dummy label.
3605 } else {
3606 |->BC_ISNEN_Z: // Dummy label.
3607 }
3608 | lwzx CARG1, BASE, RA
3609 | addi PC, PC, 4
3610 | lfdx f0, BASE, RA
3611 | lwz SAVE0, -4(PC)
3612 | lfdx f1, KBASE, RD
3613 | decode_RD4 SAVE0, SAVE0
3614 | checknum CARG1
3615 | addis SAVE0, SAVE0, -(BCBIAS_J*4 >> 16)
3616 | bge >3
3617 | fcmpu cr0, f0, f1
3618 |.endif
3619 if (vk) {
3620 | bne >1
3621 | add PC, PC, SAVE0
3622 |1:
3623 |.if not FFI
3624 |3:
3625 |.endif
3626 } else {
3627 | beq >2
3628 |1:
3629 |.if not FFI
3630 |3:
3631 |.endif
3632 | add PC, PC, SAVE0
3633 |2:
3634 }
3635 | ins_next
3636 |.if FFI
3637 |3:
3638 | cmpwi CARG1, LJ_TCDATA
3639 | beq ->vmeta_equal_cd
3640 | b <1
3641 |.endif
3642 |.if DUALNUM
3643 |7: // RA is not an integer.
3644 | bge cr0, <3
3645 | // RA is a number.
3646 | .FPU lfd f0, 0(RA)
3647 | blt cr1, >1
3648 | // RA is a number, RD is an integer.
3649 |.if FPU
3650 | tonum_i f1, CARG4
3651 |.else
3652 | bl ->vm_sfi2d_2
3653 |.endif
3654 | b >2
3655 |
3656 |8: // RA is an integer, RD is a number.
3657 |.if FPU
3658 | tonum_i f0, CARG2
3659 |.else
3660 | bl ->vm_sfi2d_1
3661 |.endif
3662 |1:
3663 | .FPU lfd f1, 0(RD)
3664 |2:
3665 |.if FPU
3666 | fcmpu cr0, f0, f1
3667 |.else
3668 | blex __ledf2
3669 | cmpwi CRET1, 0
3670 |.endif
3671 | b <4
3672 |.endif
3673 break;
3674
3675 case BC_ISEQP: case BC_ISNEP:
3676 vk = op == BC_ISEQP;
3677 | // RA = src*8, RD = primitive_type*8 (~), JMP with RD = target
3678 | lwzx TMP0, BASE, RA
3679 | srwi TMP1, RD, 3
3680 | lwz TMP2, 0(PC)
3681 | not TMP1, TMP1
3682 | addi PC, PC, 4
3683 |.if FFI
3684 | cmpwi TMP0, LJ_TCDATA
3685 |.endif
3686 | sub TMP0, TMP0, TMP1
3687 |.if FFI
3688 | beq ->vmeta_equal_cd
3689 |.endif
3690 | decode_RD4 TMP2, TMP2
3691 | .gpr64 extsw TMP0, TMP0
3692 | addic TMP0, TMP0, -1
3693 | addis TMP2, TMP2, -(BCBIAS_J*4 >> 16)
3694 | subfe TMP1, TMP1, TMP1
3695 if (vk) {
3696 | and TMP2, TMP2, TMP1
3697 } else {
3698 | andc TMP2, TMP2, TMP1
3699 }
3700 | add PC, PC, TMP2
3701 | ins_next
3702 break;
3703
3704 /* -- Unary test and copy ops ------------------------------------------- */
3705
3706 case BC_ISTC: case BC_ISFC: case BC_IST: case BC_ISF:
3707 | // RA = dst*8 or unused, RD = src*8, JMP with RD = target
3708 | lwzx TMP0, BASE, RD
3709 | lwz INS, 0(PC)
3710 | addi PC, PC, 4
3711 if (op == BC_IST || op == BC_ISF) {
3712 | .gpr64 extsw TMP0, TMP0
3713 | subfic TMP0, TMP0, LJ_TTRUE
3714 | decode_RD4 TMP2, INS
3715 | subfe TMP1, TMP1, TMP1
3716 | addis TMP2, TMP2, -(BCBIAS_J*4 >> 16)
3717 if (op == BC_IST) {
3718 | andc TMP2, TMP2, TMP1
3719 } else {
3720 | and TMP2, TMP2, TMP1
3721 }
3722 | add PC, PC, TMP2
3723 } else {
3724 | li TMP1, LJ_TFALSE
3725 |.if FPU
3726 | lfdx f0, BASE, RD
3727 |.else
3728 | lwzux CARG1, RD, BASE
3729 | lwz CARG2, 4(RD)
3730 |.endif
3731 | cmplw TMP0, TMP1
3732 if (op == BC_ISTC) {
3733 | bge >1
3734 } else {
3735 | blt >1
3736 }
3737 | addis PC, PC, -(BCBIAS_J*4 >> 16)
3738 | decode_RD4 TMP2, INS
3739 |.if FPU
3740 | stfdx f0, BASE, RA
3741 |.else
3742 | stwux CARG1, RA, BASE
3743 | stw CARG2, 4(RA)
3744 |.endif
3745 | add PC, PC, TMP2
3746 |1:
3747 }
3748 | ins_next
3749 break;
3750
3751 case BC_ISTYPE:
3752 | // RA = src*8, RD = -type*8
3753 | lwzx TMP0, BASE, RA
3754 | srwi TMP1, RD, 3
3755 | ins_next1
3756 |.if not PPE and not GPR64
3757 | add. TMP0, TMP0, TMP1
3758 |.else
3759 | neg TMP1, TMP1
3760 | cmpw TMP0, TMP1
3761 |.endif
3762 | bne ->vmeta_istype
3763 | ins_next2
3764 break;
3765 case BC_ISNUM:
3766 | // RA = src*8, RD = -(TISNUM-1)*8
3767 | lwzx TMP0, BASE, RA
3768 | ins_next1
3769 | checknum TMP0
3770 | bge ->vmeta_istype
3771 | ins_next2
3772 break;
3773
3774 /* -- Unary ops --------------------------------------------------------- */
3775
3776 case BC_MOV:
3777 | // RA = dst*8, RD = src*8
3778 | ins_next1
3779 |.if FPU
3780 | lfdx f0, BASE, RD
3781 | stfdx f0, BASE, RA
3782 |.else
3783 | lwzux TMP0, RD, BASE
3784 | lwz TMP1, 4(RD)
3785 | stwux TMP0, RA, BASE
3786 | stw TMP1, 4(RA)
3787 |.endif
3788 | ins_next2
3789 break;
3790 case BC_NOT:
3791 | // RA = dst*8, RD = src*8
3792 | ins_next1
3793 | lwzx TMP0, BASE, RD
3794 | .gpr64 extsw TMP0, TMP0
3795 | subfic TMP1, TMP0, LJ_TTRUE
3796 | adde TMP0, TMP0, TMP1
3797 | stwx TMP0, BASE, RA
3798 | ins_next2
3799 break;
3800 case BC_UNM:
3801 | // RA = dst*8, RD = src*8
3802 | lwzux TMP1, RD, BASE
3803 | lwz TMP0, 4(RD)
3804 | checknum TMP1
3805 |.if DUALNUM
3806 | bne >5
3807 |.if GPR64
3808 | lus TMP2, 0x8000
3809 | neg TMP0, TMP0
3810 | cmplw TMP0, TMP2
3811 | beq >4
3812 |.else
3813 | nego. TMP0, TMP0
3814 | bso >4
3815 |1:
3816 |.endif
3817 | ins_next1
3818 | stwux TISNUM, RA, BASE
3819 | stw TMP0, 4(RA)
3820 |3:
3821 | ins_next2
3822 |4:
3823 |.if not GPR64
3824 | // Potential overflow.
3825 | checkov TMP1, <1 // Ignore unrelated overflow.
3826 |.endif
3827 | lus TMP1, 0x41e0 // 2^31.
3828 | li TMP0, 0
3829 | b >7
3830 |.endif
3831 |5:
3832 | bge ->vmeta_unm
3833 | xoris TMP1, TMP1, 0x8000
3834 |7:
3835 | ins_next1
3836 | stwux TMP1, RA, BASE
3837 | stw TMP0, 4(RA)
3838 |.if DUALNUM
3839 | b <3
3840 |.else
3841 | ins_next2
3842 |.endif
3843 break;
3844 case BC_LEN:
3845 | // RA = dst*8, RD = src*8
3846 | lwzux TMP0, RD, BASE
3847 | lwz CARG1, 4(RD)
3848 | checkstr TMP0; bne >2
3849 | lwz CRET1, STR:CARG1->len
3850 |1:
3851 |.if DUALNUM
3852 | ins_next1
3853 | stwux TISNUM, RA, BASE
3854 | stw CRET1, 4(RA)
3855 |.else
3856 | tonum_u f0, CRET1 // Result is a non-negative integer.
3857 | ins_next1
3858 | stfdx f0, BASE, RA
3859 |.endif
3860 | ins_next2
3861 |2:
3862 | checktab TMP0; bne ->vmeta_len
3863 #if LJ_52
3864 | lwz TAB:TMP2, TAB:CARG1->metatable
3865 | cmplwi TAB:TMP2, 0
3866 | bne >9
3867 |3:
3868 #endif
3869 |->BC_LEN_Z:
3870 | bl extern lj_tab_len // (GCtab *t)
3871 | // Returns uint32_t (but less than 2^31).
3872 | b <1
3873 #if LJ_52
3874 |9:
3875 | lbz TMP0, TAB:TMP2->nomm
3876 | andix. TMP0, TMP0, 1<<MM_len
3877 | bne <3 // 'no __len' flag set: done.
3878 | b ->vmeta_len
3879 #endif
3880 break;
3881
3882 /* -- Binary ops -------------------------------------------------------- */
3883
3884 |.macro ins_arithpre
3885 | // RA = dst*8, RB = src1*8, RC = src2*8 | num_const*8
3886 ||vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
3887 ||switch (vk) {
3888 ||case 0:
3889 | lwzx CARG1, BASE, RB
3890 | .if DUALNUM
3891 | lwzx CARG3, KBASE, RC
3892 | .endif
3893 | .if FPU
3894 | lfdx f14, BASE, RB
3895 | lfdx f15, KBASE, RC
3896 | .else
3897 | add TMP1, BASE, RB
3898 | add TMP2, KBASE, RC
3899 | lwz CARG2, 4(TMP1)
3900 | lwz CARG4, 4(TMP2)
3901 | .endif
3902 | .if DUALNUM
3903 | checknum cr0, CARG1
3904 | checknum cr1, CARG3
3905 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
3906 | bge ->vmeta_arith_vn
3907 | .else
3908 | checknum CARG1; bge ->vmeta_arith_vn
3909 | .endif
3910 || break;
3911 ||case 1:
3912 | lwzx CARG1, BASE, RB
3913 | .if DUALNUM
3914 | lwzx CARG3, KBASE, RC
3915 | .endif
3916 | .if FPU
3917 | lfdx f15, BASE, RB
3918 | lfdx f14, KBASE, RC
3919 | .else
3920 | add TMP1, BASE, RB
3921 | add TMP2, KBASE, RC
3922 | lwz CARG2, 4(TMP1)
3923 | lwz CARG4, 4(TMP2)
3924 | .endif
3925 | .if DUALNUM
3926 | checknum cr0, CARG1
3927 | checknum cr1, CARG3
3928 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
3929 | bge ->vmeta_arith_nv
3930 | .else
3931 | checknum CARG1; bge ->vmeta_arith_nv
3932 | .endif
3933 || break;
3934 ||default:
3935 | lwzx CARG1, BASE, RB
3936 | lwzx CARG3, BASE, RC
3937 | .if FPU
3938 | lfdx f14, BASE, RB
3939 | lfdx f15, BASE, RC
3940 | .else
3941 | add TMP1, BASE, RB
3942 | add TMP2, BASE, RC
3943 | lwz CARG2, 4(TMP1)
3944 | lwz CARG4, 4(TMP2)
3945 | .endif
3946 | checknum cr0, CARG1
3947 | checknum cr1, CARG3
3948 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
3949 | bge ->vmeta_arith_vv
3950 || break;
3951 ||}
3952 |.endmacro
3953 |
3954 |.macro ins_arithfallback, ins
3955 ||switch (vk) {
3956 ||case 0:
3957 | ins ->vmeta_arith_vn2
3958 || break;
3959 ||case 1:
3960 | ins ->vmeta_arith_nv2
3961 || break;
3962 ||default:
3963 | ins ->vmeta_arith_vv2
3964 || break;
3965 ||}
3966 |.endmacro
3967 |
3968 |.macro intmod, a, b, c
3969 | bl ->vm_modi
3970 |.endmacro
3971 |
3972 |.macro fpmod, a, b, c
3973 |->BC_MODVN_Z:
3974 | fdiv FARG1, b, c
3975 | // NYI: Use internal implementation of floor.
3976 | blex floor // floor(b/c)
3977 | fmul a, FARG1, c
3978 | fsub a, b, a // b - floor(b/c)*c
3979 |.endmacro
3980 |
3981 |.macro sfpmod
3982 |->BC_MODVN_Z:
3983 | stw CARG1, SFSAVE_1
3984 | stw CARG2, SFSAVE_2
3985 | mr SAVE0, CARG3
3986 | mr SAVE1, CARG4
3987 | blex __divdf3
3988 | blex floor
3989 | mr CARG3, SAVE0
3990 | mr CARG4, SAVE1
3991 | blex __muldf3
3992 | mr CARG3, CRET1
3993 | mr CARG4, CRET2
3994 | lwz CARG1, SFSAVE_1
3995 | lwz CARG2, SFSAVE_2
3996 | blex __subdf3
3997 |.endmacro
3998 |
3999 |.macro ins_arithfp, fpins
4000 | ins_arithpre
4001 |.if "fpins" == "fpmod_"
4002 | b ->BC_MODVN_Z // Avoid 3 copies. It's slow anyway.
4003 |.elif FPU
4004 | fpins f0, f14, f15
4005 | ins_next1
4006 | stfdx f0, BASE, RA
4007 | ins_next2
4008 |.else
4009 | blex __divdf3 // Only soft-float div uses this macro.
4010 | ins_next1
4011 | stwux CRET1, RA, BASE
4012 | stw CRET2, 4(RA)
4013 | ins_next2
4014 |.endif
4015 |.endmacro
4016 |
4017 |.macro ins_arithdn, intins, fpins, fpcall
4018 | // RA = dst*8, RB = src1*8, RC = src2*8 | num_const*8
4019 ||vk = ((int)op - BC_ADDVN) / (BC_ADDNV-BC_ADDVN);
4020 ||switch (vk) {
4021 ||case 0:
4022 | lwzux CARG1, RB, BASE
4023 | lwzux CARG3, RC, KBASE
4024 | lwz CARG2, 4(RB)
4025 | checknum cr0, CARG1
4026 | lwz CARG4, 4(RC)
4027 | checknum cr1, CARG3
4028 || break;
4029 ||case 1:
4030 | lwzux CARG3, RB, BASE
4031 | lwzux CARG1, RC, KBASE
4032 | lwz CARG4, 4(RB)
4033 | checknum cr0, CARG3
4034 | lwz CARG2, 4(RC)
4035 | checknum cr1, CARG1
4036 || break;
4037 ||default:
4038 | lwzux CARG1, RB, BASE
4039 | lwzux CARG3, RC, BASE
4040 | lwz CARG2, 4(RB)
4041 | checknum cr0, CARG1
4042 | lwz CARG4, 4(RC)
4043 | checknum cr1, CARG3
4044 || break;
4045 ||}
4046 | bne >5
4047 | bne cr1, >5
4048 |.if "intins" == "intmod"
4049 | mr CARG1, CARG2
4050 | mr CARG2, CARG4
4051 |.endif
4052 | intins CARG1, CARG2, CARG4
4053 | bso >4
4054 |1:
4055 | ins_next1
4056 | stwux TISNUM, RA, BASE
4057 | stw CARG1, 4(RA)
4058 |2:
4059 | ins_next2
4060 |4: // Overflow.
4061 | checkov TMP0, <1 // Ignore unrelated overflow.
4062 | ins_arithfallback b
4063 |5: // FP variant.
4064 |.if FPU
4065 ||if (vk == 1) {
4066 | lfd f15, 0(RB)
4067 | lfd f14, 0(RC)
4068 ||} else {
4069 | lfd f14, 0(RB)
4070 | lfd f15, 0(RC)
4071 ||}
4072 |.endif
4073 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
4074 | ins_arithfallback bge
4075 |.if "fpins" == "fpmod_"
4076 | b ->BC_MODVN_Z // Avoid 3 copies. It's slow anyway.
4077 |.else
4078 |.if FPU
4079 | fpins f0, f14, f15
4080 | stfdx f0, BASE, RA
4081 |.else
4082 |.if "fpcall" == "sfpmod"
4083 | sfpmod
4084 |.else
4085 | blex fpcall
4086 |.endif
4087 | stwux CRET1, RA, BASE
4088 | stw CRET2, 4(RA)
4089 |.endif
4090 | ins_next1
4091 | b <2
4092 |.endif
4093 |.endmacro
4094 |
4095 |.macro ins_arith, intins, fpins, fpcall
4096 |.if DUALNUM
4097 | ins_arithdn intins, fpins, fpcall
4098 |.else
4099 | ins_arithfp fpins
4100 |.endif
4101 |.endmacro
4102
4103 case BC_ADDVN: case BC_ADDNV: case BC_ADDVV:
4104 |.if GPR64
4105 |.macro addo32., y, a, b
4106 | // Need to check overflow for (a<<32) + (b<<32).
4107 | rldicr TMP0, a, 32, 31
4108 | rldicr TMP1, b, 32, 31
4109 | addo. TMP0, TMP0, TMP1
4110 | add y, a, b
4111 |.endmacro
4112 | ins_arith addo32., fadd, __adddf3
4113 |.else
4114 | ins_arith addo., fadd, __adddf3
4115 |.endif
4116 break;
4117 case BC_SUBVN: case BC_SUBNV: case BC_SUBVV:
4118 |.if GPR64
4119 |.macro subo32., y, a, b
4120 | // Need to check overflow for (a<<32) - (b<<32).
4121 | rldicr TMP0, a, 32, 31
4122 | rldicr TMP1, b, 32, 31
4123 | subo. TMP0, TMP0, TMP1
4124 | sub y, a, b
4125 |.endmacro
4126 | ins_arith subo32., fsub, __subdf3
4127 |.else
4128 | ins_arith subo., fsub, __subdf3
4129 |.endif
4130 break;
4131 case BC_MULVN: case BC_MULNV: case BC_MULVV:
4132 | ins_arith mullwo., fmul, __muldf3
4133 break;
4134 case BC_DIVVN: case BC_DIVNV: case BC_DIVVV:
4135 | ins_arithfp fdiv
4136 break;
4137 case BC_MODVN:
4138 | ins_arith intmod, fpmod, sfpmod
4139 break;
4140 case BC_MODNV: case BC_MODVV:
4141 | ins_arith intmod, fpmod_, sfpmod
4142 break;
4143 case BC_POW:
4144 | // NYI: (partial) integer arithmetic.
4145 | lwzx CARG1, BASE, RB
4146 | lwzx CARG3, BASE, RC
4147 |.if FPU
4148 | lfdx FARG1, BASE, RB
4149 | lfdx FARG2, BASE, RC
4150 |.else
4151 | add TMP1, BASE, RB
4152 | add TMP2, BASE, RC
4153 | lwz CARG2, 4(TMP1)
4154 | lwz CARG4, 4(TMP2)
4155 |.endif
4156 | checknum cr0, CARG1
4157 | checknum cr1, CARG3
4158 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
4159 | bge ->vmeta_arith_vv
4160 | blex pow
4161 | ins_next1
4162 |.if FPU
4163 | stfdx FARG1, BASE, RA
4164 |.else
4165 | stwux CARG1, RA, BASE
4166 | stw CARG2, 4(RA)
4167 |.endif
4168 | ins_next2
4169 break;
4170
4171 case BC_CAT:
4172 | // RA = dst*8, RB = src_start*8, RC = src_end*8
4173 | sub CARG3, RC, RB
4174 | stp BASE, L->base
4175 | add CARG2, BASE, RC
4176 | mr SAVE0, RB
4177 |->BC_CAT_Z:
4178 | stw PC, SAVE_PC
4179 | mr CARG1, L
4180 | srwi CARG3, CARG3, 3
4181 | bl extern lj_meta_cat // (lua_State *L, TValue *top, int left)
4182 | // Returns NULL (finished) or TValue * (metamethod).
4183 | cmplwi CRET1, 0
4184 | lp BASE, L->base
4185 | bne ->vmeta_binop
4186 | ins_next1
4187 |.if FPU
4188 | lfdx f0, BASE, SAVE0 // Copy result from RB to RA.
4189 | stfdx f0, BASE, RA
4190 |.else
4191 | lwzux TMP0, SAVE0, BASE
4192 | lwz TMP1, 4(SAVE0)
4193 | stwux TMP0, RA, BASE
4194 | stw TMP1, 4(RA)
4195 |.endif
4196 | ins_next2
4197 break;
4198
4199 /* -- Constant ops ------------------------------------------------------ */
4200
4201 case BC_KSTR:
4202 | // RA = dst*8, RD = str_const*8 (~)
4203 | srwi TMP1, RD, 1
4204 | subfic TMP1, TMP1, -4
4205 | ins_next1
4206 | lwzx TMP0, KBASE, TMP1 // KBASE-4-str_const*4
4207 | li TMP2, LJ_TSTR
4208 | stwux TMP2, RA, BASE
4209 | stw TMP0, 4(RA)
4210 | ins_next2
4211 break;
4212 case BC_KCDATA:
4213 |.if FFI
4214 | // RA = dst*8, RD = cdata_const*8 (~)
4215 | srwi TMP1, RD, 1
4216 | subfic TMP1, TMP1, -4
4217 | ins_next1
4218 | lwzx TMP0, KBASE, TMP1 // KBASE-4-cdata_const*4
4219 | li TMP2, LJ_TCDATA
4220 | stwux TMP2, RA, BASE
4221 | stw TMP0, 4(RA)
4222 | ins_next2
4223 |.endif
4224 break;
4225 case BC_KSHORT:
4226 | // RA = dst*8, RD = int16_literal*8
4227 |.if DUALNUM
4228 | slwi RD, RD, 13
4229 | srawi RD, RD, 16
4230 | ins_next1
4231 | stwux TISNUM, RA, BASE
4232 | stw RD, 4(RA)
4233 | ins_next2
4234 |.else
4235 | // The soft-float approach is faster.
4236 | slwi RD, RD, 13
4237 | srawi TMP1, RD, 31
4238 | xor TMP2, TMP1, RD
4239 | sub TMP2, TMP2, TMP1 // TMP2 = abs(x)
4240 | cntlzw TMP3, TMP2
4241 | subfic TMP1, TMP3, 0x40d // TMP1 = exponent-1
4242 | slw TMP2, TMP2, TMP3 // TMP2 = left aligned mantissa
4243 | subfic TMP3, RD, 0
4244 | slwi TMP1, TMP1, 20
4245 | rlwimi RD, TMP2, 21, 1, 31 // hi = sign(x) | (mantissa>>11)
4246 | subfe TMP0, TMP0, TMP0
4247 | add RD, RD, TMP1 // hi = hi + exponent-1
4248 | and RD, RD, TMP0 // hi = x == 0 ? 0 : hi
4249 | ins_next1
4250 | stwux RD, RA, BASE
4251 | stw ZERO, 4(RA)
4252 | ins_next2
4253 |.endif
4254 break;
4255 case BC_KNUM:
4256 | // RA = dst*8, RD = num_const*8
4257 | ins_next1
4258 |.if FPU
4259 | lfdx f0, KBASE, RD
4260 | stfdx f0, BASE, RA
4261 |.else
4262 | lwzux TMP0, RD, KBASE
4263 | lwz TMP1, 4(RD)
4264 | stwux TMP0, RA, BASE
4265 | stw TMP1, 4(RA)
4266 |.endif
4267 | ins_next2
4268 break;
4269 case BC_KPRI:
4270 | // RA = dst*8, RD = primitive_type*8 (~)
4271 | srwi TMP1, RD, 3
4272 | not TMP0, TMP1
4273 | ins_next1
4274 | stwx TMP0, BASE, RA
4275 | ins_next2
4276 break;
4277 case BC_KNIL:
4278 | // RA = base*8, RD = end*8
4279 | stwx TISNIL, BASE, RA
4280 | addi RA, RA, 8
4281 |1:
4282 | stwx TISNIL, BASE, RA
4283 | cmpw RA, RD
4284 | addi RA, RA, 8
4285 | blt <1
4286 | ins_next_
4287 break;
4288
4289 /* -- Upvalue and function ops ------------------------------------------ */
4290
4291 case BC_UGET:
4292 | // RA = dst*8, RD = uvnum*8
4293 | lwz LFUNC:RB, FRAME_FUNC(BASE)
4294 | srwi RD, RD, 1
4295 | addi RD, RD, offsetof(GCfuncL, uvptr)
4296 | lwzx UPVAL:RB, LFUNC:RB, RD
4297 | ins_next1
4298 | lwz TMP1, UPVAL:RB->v
4299 |.if FPU
4300 | lfd f0, 0(TMP1)
4301 | stfdx f0, BASE, RA
4302 |.else
4303 | lwz TMP2, 0(TMP1)
4304 | lwz TMP3, 4(TMP1)
4305 | stwux TMP2, RA, BASE
4306 | stw TMP3, 4(RA)
4307 |.endif
4308 | ins_next2
4309 break;
4310 case BC_USETV:
4311 | // RA = uvnum*8, RD = src*8
4312 | lwz LFUNC:RB, FRAME_FUNC(BASE)
4313 | srwi RA, RA, 1
4314 | addi RA, RA, offsetof(GCfuncL, uvptr)
4315 |.if FPU
4316 | lfdux f0, RD, BASE
4317 |.else
4318 | lwzux CARG1, RD, BASE
4319 | lwz CARG3, 4(RD)
4320 |.endif
4321 | lwzx UPVAL:RB, LFUNC:RB, RA
4322 | lbz TMP3, UPVAL:RB->marked
4323 | lwz CARG2, UPVAL:RB->v
4324 | andix. TMP3, TMP3, LJ_GC_BLACK // isblack(uv)
4325 | lbz TMP0, UPVAL:RB->closed
4326 | lwz TMP2, 0(RD)
4327 |.if FPU
4328 | stfd f0, 0(CARG2)
4329 |.else
4330 | stw CARG1, 0(CARG2)
4331 | stw CARG3, 4(CARG2)
4332 |.endif
4333 | cmplwi cr1, TMP0, 0
4334 | lwz TMP1, 4(RD)
4335 | cror 4*cr0+eq, 4*cr0+eq, 4*cr1+eq
4336 | subi TMP2, TMP2, (LJ_TNUMX+1)
4337 | bne >2 // Upvalue is closed and black?
4338 |1:
4339 | ins_next
4340 |
4341 |2: // Check if new value is collectable.
4342 | cmplwi TMP2, LJ_TISGCV - (LJ_TNUMX+1)
4343 | bge <1 // tvisgcv(v)
4344 | lbz TMP3, GCOBJ:TMP1->gch.marked
4345 | andix. TMP3, TMP3, LJ_GC_WHITES // iswhite(v)
4346 | la CARG1, GG_DISP2G(DISPATCH)
4347 | // Crossed a write barrier. Move the barrier forward.
4348 | beq <1
4349 | bl extern lj_gc_barrieruv // (global_State *g, TValue *tv)
4350 | b <1
4351 break;
4352 case BC_USETS:
4353 | // RA = uvnum*8, RD = str_const*8 (~)
4354 | lwz LFUNC:RB, FRAME_FUNC(BASE)
4355 | srwi TMP1, RD, 1
4356 | srwi RA, RA, 1
4357 | subfic TMP1, TMP1, -4
4358 | addi RA, RA, offsetof(GCfuncL, uvptr)
4359 | lwzx STR:TMP1, KBASE, TMP1 // KBASE-4-str_const*4
4360 | lwzx UPVAL:RB, LFUNC:RB, RA
4361 | lbz TMP3, UPVAL:RB->marked
4362 | lwz CARG2, UPVAL:RB->v
4363 | andix. TMP3, TMP3, LJ_GC_BLACK // isblack(uv)
4364 | lbz TMP3, STR:TMP1->marked
4365 | lbz TMP2, UPVAL:RB->closed
4366 | li TMP0, LJ_TSTR
4367 | stw STR:TMP1, 4(CARG2)
4368 | stw TMP0, 0(CARG2)
4369 | bne >2
4370 |1:
4371 | ins_next
4372 |
4373 |2: // Check if string is white and ensure upvalue is closed.
4374 | andix. TMP3, TMP3, LJ_GC_WHITES // iswhite(str)
4375 | cmplwi cr1, TMP2, 0
4376 | cror 4*cr0+eq, 4*cr0+eq, 4*cr1+eq
4377 | la CARG1, GG_DISP2G(DISPATCH)
4378 | // Crossed a write barrier. Move the barrier forward.
4379 | beq <1
4380 | bl extern lj_gc_barrieruv // (global_State *g, TValue *tv)
4381 | b <1
4382 break;
4383 case BC_USETN:
4384 | // RA = uvnum*8, RD = num_const*8
4385 | lwz LFUNC:RB, FRAME_FUNC(BASE)
4386 | srwi RA, RA, 1
4387 | addi RA, RA, offsetof(GCfuncL, uvptr)
4388 |.if FPU
4389 | lfdx f0, KBASE, RD
4390 |.else
4391 | lwzux TMP2, RD, KBASE
4392 | lwz TMP3, 4(RD)
4393 |.endif
4394 | lwzx UPVAL:RB, LFUNC:RB, RA
4395 | ins_next1
4396 | lwz TMP1, UPVAL:RB->v
4397 |.if FPU
4398 | stfd f0, 0(TMP1)
4399 |.else
4400 | stw TMP2, 0(TMP1)
4401 | stw TMP3, 4(TMP1)
4402 |.endif
4403 | ins_next2
4404 break;
4405 case BC_USETP:
4406 | // RA = uvnum*8, RD = primitive_type*8 (~)
4407 | lwz LFUNC:RB, FRAME_FUNC(BASE)
4408 | srwi RA, RA, 1
4409 | srwi TMP0, RD, 3
4410 | addi RA, RA, offsetof(GCfuncL, uvptr)
4411 | not TMP0, TMP0
4412 | lwzx UPVAL:RB, LFUNC:RB, RA
4413 | ins_next1
4414 | lwz TMP1, UPVAL:RB->v
4415 | stw TMP0, 0(TMP1)
4416 | ins_next2
4417 break;
4418
4419 case BC_UCLO:
4420 | // RA = level*8, RD = target
4421 | lwz TMP1, L->openupval
4422 | branch_RD // Do this first since RD is not saved.
4423 | stp BASE, L->base
4424 | cmplwi TMP1, 0
4425 | mr CARG1, L
4426 | beq >1
4427 | add CARG2, BASE, RA
4428 | bl extern lj_func_closeuv // (lua_State *L, TValue *level)
4429 | lp BASE, L->base
4430 |1:
4431 | ins_next
4432 break;
4433
4434 case BC_FNEW:
4435 | // RA = dst*8, RD = proto_const*8 (~) (holding function prototype)
4436 | srwi TMP1, RD, 1
4437 | stp BASE, L->base
4438 | subfic TMP1, TMP1, -4
4439 | stw PC, SAVE_PC
4440 | lwzx CARG2, KBASE, TMP1 // KBASE-4-tab_const*4
4441 | mr CARG1, L
4442 | lwz CARG3, FRAME_FUNC(BASE)
4443 | // (lua_State *L, GCproto *pt, GCfuncL *parent)
4444 | bl extern lj_func_newL_gc
4445 | // Returns GCfuncL *.
4446 | lp BASE, L->base
4447 | li TMP0, LJ_TFUNC
4448 | stwux TMP0, RA, BASE
4449 | stw LFUNC:CRET1, 4(RA)
4450 | ins_next
4451 break;
4452
4453 /* -- Table ops --------------------------------------------------------- */
4454
4455 case BC_TNEW:
4456 case BC_TDUP:
4457 | // RA = dst*8, RD = (hbits|asize)*8 | tab_const*8 (~)
4458 | lwz TMP0, DISPATCH_GL(gc.total)(DISPATCH)
4459 | mr CARG1, L
4460 | lwz TMP1, DISPATCH_GL(gc.threshold)(DISPATCH)
4461 | stp BASE, L->base
4462 | cmplw TMP0, TMP1
4463 | stw PC, SAVE_PC
4464 | bge >5
4465 |1:
4466 if (op == BC_TNEW) {
4467 | rlwinm CARG2, RD, 29, 21, 31
4468 | rlwinm CARG3, RD, 18, 27, 31
4469 | cmpwi CARG2, 0x7ff; beq >3
4470 |2:
4471 | bl extern lj_tab_new // (lua_State *L, int32_t asize, uint32_t hbits)
4472 | // Returns Table *.
4473 } else {
4474 | srwi TMP1, RD, 1
4475 | subfic TMP1, TMP1, -4
4476 | lwzx CARG2, KBASE, TMP1 // KBASE-4-tab_const*4
4477 | bl extern lj_tab_dup // (lua_State *L, Table *kt)
4478 | // Returns Table *.
4479 }
4480 | lp BASE, L->base
4481 | li TMP0, LJ_TTAB
4482 | stwux TMP0, RA, BASE
4483 | stw TAB:CRET1, 4(RA)
4484 | ins_next
4485 if (op == BC_TNEW) {
4486 |3:
4487 | li CARG2, 0x801
4488 | b <2
4489 }
4490 |5:
4491 | mr SAVE0, RD
4492 | bl extern lj_gc_step_fixtop // (lua_State *L)
4493 | mr RD, SAVE0
4494 | mr CARG1, L
4495 | b <1
4496 break;
4497
4498 case BC_GGET:
4499 | // RA = dst*8, RD = str_const*8 (~)
4500 case BC_GSET:
4501 | // RA = src*8, RD = str_const*8 (~)
4502 | lwz LFUNC:TMP2, FRAME_FUNC(BASE)
4503 | srwi TMP1, RD, 1
4504 | lwz TAB:RB, LFUNC:TMP2->env
4505 | subfic TMP1, TMP1, -4
4506 | lwzx STR:RC, KBASE, TMP1 // KBASE-4-str_const*4
4507 if (op == BC_GGET) {
4508 | b ->BC_TGETS_Z
4509 } else {
4510 | b ->BC_TSETS_Z
4511 }
4512 break;
4513
4514 case BC_TGETV:
4515 | // RA = dst*8, RB = table*8, RC = key*8
4516 | lwzux CARG1, RB, BASE
4517 | lwzux CARG2, RC, BASE
4518 | lwz TAB:RB, 4(RB)
4519 |.if DUALNUM
4520 | lwz RC, 4(RC)
4521 |.else
4522 | lfd f0, 0(RC)
4523 |.endif
4524 | checktab CARG1
4525 | checknum cr1, CARG2
4526 | bne ->vmeta_tgetv
4527 |.if DUALNUM
4528 | lwz TMP0, TAB:RB->asize
4529 | bne cr1, >5
4530 | lwz TMP1, TAB:RB->array
4531 | cmplw TMP0, RC
4532 | slwi TMP2, RC, 3
4533 |.else
4534 | bge cr1, >5
4535 | // Convert number key to integer, check for integerness and range.
4536 | fctiwz f1, f0
4537 | fadd f2, f0, TOBIT
4538 | stfd f1, TMPD
4539 | lwz TMP0, TAB:RB->asize
4540 | fsub f2, f2, TOBIT
4541 | lwz TMP2, TMPD_LO
4542 | lwz TMP1, TAB:RB->array
4543 | fcmpu cr1, f0, f2
4544 | cmplw cr0, TMP0, TMP2
4545 | crand 4*cr0+gt, 4*cr0+gt, 4*cr1+eq
4546 | slwi TMP2, TMP2, 3
4547 |.endif
4548 | ble ->vmeta_tgetv // Integer key and in array part?
4549 | lwzx TMP0, TMP1, TMP2
4550 |.if FPU
4551 | lfdx f14, TMP1, TMP2
4552 |.else
4553 | lwzux SAVE0, TMP1, TMP2
4554 | lwz SAVE1, 4(TMP1)
4555 |.endif
4556 | checknil TMP0; beq >2
4557 |1:
4558 | ins_next1
4559 |.if FPU
4560 | stfdx f14, BASE, RA
4561 |.else
4562 | stwux SAVE0, RA, BASE
4563 | stw SAVE1, 4(RA)
4564 |.endif
4565 | ins_next2
4566 |
4567 |2: // Check for __index if table value is nil.
4568 | lwz TAB:TMP2, TAB:RB->metatable
4569 | cmplwi TAB:TMP2, 0
4570 | beq <1 // No metatable: done.
4571 | lbz TMP0, TAB:TMP2->nomm
4572 | andix. TMP0, TMP0, 1<<MM_index
4573 | bne <1 // 'no __index' flag set: done.
4574 | b ->vmeta_tgetv
4575 |
4576 |5:
4577 | checkstr CARG2; bne ->vmeta_tgetv
4578 |.if not DUALNUM
4579 | lwz STR:RC, 4(RC)
4580 |.endif
4581 | b ->BC_TGETS_Z // String key?
4582 break;
4583 case BC_TGETS:
4584 | // RA = dst*8, RB = table*8, RC = str_const*8 (~)
4585 | lwzux CARG1, RB, BASE
4586 | srwi TMP1, RC, 1
4587 | lwz TAB:RB, 4(RB)
4588 | subfic TMP1, TMP1, -4
4589 | checktab CARG1
4590 | lwzx STR:RC, KBASE, TMP1 // KBASE-4-str_const*4
4591 | bne ->vmeta_tgets1
4592 |->BC_TGETS_Z:
4593 | // TAB:RB = GCtab *, STR:RC = GCstr *, RA = dst*8
4594 | lwz TMP0, TAB:RB->hmask
4595 | lwz TMP1, STR:RC->sid
4596 | lwz NODE:TMP2, TAB:RB->node
4597 | and TMP1, TMP1, TMP0 // idx = str->sid & tab->hmask
4598 | slwi TMP0, TMP1, 5
4599 | slwi TMP1, TMP1, 3
4600 | sub TMP1, TMP0, TMP1
4601 | add NODE:TMP2, NODE:TMP2, TMP1 // node = tab->node + (idx*32-idx*8)
4602 |1:
4603 | lwz CARG1, NODE:TMP2->key
4604 | lwz TMP0, 4+offsetof(Node, key)(NODE:TMP2)
4605 | lwz CARG2, NODE:TMP2->val
4606 | lwz TMP1, 4+offsetof(Node, val)(NODE:TMP2)
4607 | checkstr CARG1; bne >4
4608 | cmpw TMP0, STR:RC; bne >4
4609 | checknil CARG2; beq >5 // Key found, but nil value?
4610 |3:
4611 | stwux CARG2, RA, BASE
4612 | stw TMP1, 4(RA)
4613 | ins_next
4614 |
4615 |4: // Follow hash chain.
4616 | lwz NODE:TMP2, NODE:TMP2->next
4617 | cmplwi NODE:TMP2, 0
4618 | bne <1
4619 | // End of hash chain: key not found, nil result.
4620 | li CARG2, LJ_TNIL
4621 |
4622 |5: // Check for __index if table value is nil.
4623 | lwz TAB:TMP2, TAB:RB->metatable
4624 | cmplwi TAB:TMP2, 0
4625 | beq <3 // No metatable: done.
4626 | lbz TMP0, TAB:TMP2->nomm
4627 | andix. TMP0, TMP0, 1<<MM_index
4628 | bne <3 // 'no __index' flag set: done.
4629 | b ->vmeta_tgets
4630 break;
4631 case BC_TGETB:
4632 | // RA = dst*8, RB = table*8, RC = index*8
4633 | lwzux CARG1, RB, BASE
4634 | srwi TMP0, RC, 3
4635 | lwz TAB:RB, 4(RB)
4636 | checktab CARG1; bne ->vmeta_tgetb
4637 | lwz TMP1, TAB:RB->asize
4638 | lwz TMP2, TAB:RB->array
4639 | cmplw TMP0, TMP1; bge ->vmeta_tgetb
4640 |.if FPU
4641 | lwzx TMP1, TMP2, RC
4642 | lfdx f0, TMP2, RC
4643 |.else
4644 | lwzux TMP1, TMP2, RC
4645 | lwz TMP3, 4(TMP2)
4646 |.endif
4647 | checknil TMP1; beq >5
4648 |1:
4649 | ins_next1
4650 |.if FPU
4651 | stfdx f0, BASE, RA
4652 |.else
4653 | stwux TMP1, RA, BASE
4654 | stw TMP3, 4(RA)
4655 |.endif
4656 | ins_next2
4657 |
4658 |5: // Check for __index if table value is nil.
4659 | lwz TAB:TMP2, TAB:RB->metatable
4660 | cmplwi TAB:TMP2, 0
4661 | beq <1 // No metatable: done.
4662 | lbz TMP2, TAB:TMP2->nomm
4663 | andix. TMP2, TMP2, 1<<MM_index
4664 | bne <1 // 'no __index' flag set: done.
4665 | b ->vmeta_tgetb // Caveat: preserve TMP0!
4666 break;
4667 case BC_TGETR:
4668 | // RA = dst*8, RB = table*8, RC = key*8
4669 | add RB, BASE, RB
4670 | lwz TAB:CARG1, 4(RB)
4671 |.if DUALNUM
4672 | add RC, BASE, RC
4673 | lwz TMP0, TAB:CARG1->asize
4674 | lwz CARG2, 4(RC)
4675 | lwz TMP1, TAB:CARG1->array
4676 |.else
4677 | lfdx f0, BASE, RC
4678 | lwz TMP0, TAB:CARG1->asize
4679 | toint CARG2, f0
4680 | lwz TMP1, TAB:CARG1->array
4681 |.endif
4682 | cmplw TMP0, CARG2
4683 | slwi TMP2, CARG2, 3
4684 | ble ->vmeta_tgetr // In array part?
4685 |.if FPU
4686 | lfdx f14, TMP1, TMP2
4687 |.else
4688 | lwzux SAVE0, TMP2, TMP1
4689 | lwz SAVE1, 4(TMP2)
4690 |.endif
4691 |->BC_TGETR_Z:
4692 | ins_next1
4693 |.if FPU
4694 | stfdx f14, BASE, RA
4695 |.else
4696 | stwux SAVE0, RA, BASE
4697 | stw SAVE1, 4(RA)
4698 |.endif
4699 | ins_next2
4700 break;
4701
4702 case BC_TSETV:
4703 | // RA = src*8, RB = table*8, RC = key*8
4704 | lwzux CARG1, RB, BASE
4705 | lwzux CARG2, RC, BASE
4706 | lwz TAB:RB, 4(RB)
4707 |.if DUALNUM
4708 | lwz RC, 4(RC)
4709 |.else
4710 | lfd f0, 0(RC)
4711 |.endif
4712 | checktab CARG1
4713 | checknum cr1, CARG2
4714 | bne ->vmeta_tsetv
4715 |.if DUALNUM
4716 | lwz TMP0, TAB:RB->asize
4717 | bne cr1, >5
4718 | lwz TMP1, TAB:RB->array
4719 | cmplw TMP0, RC
4720 | slwi TMP0, RC, 3
4721 |.else
4722 | bge cr1, >5
4723 | // Convert number key to integer, check for integerness and range.
4724 | fctiwz f1, f0
4725 | fadd f2, f0, TOBIT
4726 | stfd f1, TMPD
4727 | lwz TMP0, TAB:RB->asize
4728 | fsub f2, f2, TOBIT
4729 | lwz TMP2, TMPD_LO
4730 | lwz TMP1, TAB:RB->array
4731 | fcmpu cr1, f0, f2
4732 | cmplw cr0, TMP0, TMP2
4733 | crand 4*cr0+gt, 4*cr0+gt, 4*cr1+eq
4734 | slwi TMP0, TMP2, 3
4735 |.endif
4736 | ble ->vmeta_tsetv // Integer key and in array part?
4737 | lwzx TMP2, TMP1, TMP0
4738 | lbz TMP3, TAB:RB->marked
4739 |.if FPU
4740 | lfdx f14, BASE, RA
4741 |.else
4742 | add SAVE1, BASE, RA
4743 | lwz SAVE0, 0(SAVE1)
4744 | lwz SAVE1, 4(SAVE1)
4745 |.endif
4746 | checknil TMP2; beq >3
4747 |1:
4748 | andix. TMP2, TMP3, LJ_GC_BLACK // isblack(table)
4749 |.if FPU
4750 | stfdx f14, TMP1, TMP0
4751 |.else
4752 | stwux SAVE0, TMP1, TMP0
4753 | stw SAVE1, 4(TMP1)
4754 |.endif
4755 | bne >7
4756 |2:
4757 | ins_next
4758 |
4759 |3: // Check for __newindex if previous value is nil.
4760 | lwz TAB:TMP2, TAB:RB->metatable
4761 | cmplwi TAB:TMP2, 0
4762 | beq <1 // No metatable: done.
4763 | lbz TMP2, TAB:TMP2->nomm
4764 | andix. TMP2, TMP2, 1<<MM_newindex
4765 | bne <1 // 'no __newindex' flag set: done.
4766 | b ->vmeta_tsetv
4767 |
4768 |5:
4769 | checkstr CARG2; bne ->vmeta_tsetv
4770 |.if not DUALNUM
4771 | lwz STR:RC, 4(RC)
4772 |.endif
4773 | b ->BC_TSETS_Z // String key?
4774 |
4775 |7: // Possible table write barrier for the value. Skip valiswhite check.
4776 | barrierback TAB:RB, TMP3, TMP0
4777 | b <2
4778 break;
4779 case BC_TSETS:
4780 | // RA = src*8, RB = table*8, RC = str_const*8 (~)
4781 | lwzux CARG1, RB, BASE
4782 | srwi TMP1, RC, 1
4783 | lwz TAB:RB, 4(RB)
4784 | subfic TMP1, TMP1, -4
4785 | checktab CARG1
4786 | lwzx STR:RC, KBASE, TMP1 // KBASE-4-str_const*4
4787 | bne ->vmeta_tsets1
4788 |->BC_TSETS_Z:
4789 | // TAB:RB = GCtab *, STR:RC = GCstr *, RA = src*8
4790 | lwz TMP0, TAB:RB->hmask
4791 | lwz TMP1, STR:RC->sid
4792 | lwz NODE:TMP2, TAB:RB->node
4793 | stb ZERO, TAB:RB->nomm // Clear metamethod cache.
4794 | and TMP1, TMP1, TMP0 // idx = str->sid & tab->hmask
4795 |.if FPU
4796 | lfdx f14, BASE, RA
4797 |.else
4798 | add CARG2, BASE, RA
4799 | lwz SAVE0, 0(CARG2)
4800 | lwz SAVE1, 4(CARG2)
4801 |.endif
4802 | slwi TMP0, TMP1, 5
4803 | slwi TMP1, TMP1, 3
4804 | sub TMP1, TMP0, TMP1
4805 | lbz TMP3, TAB:RB->marked
4806 | add NODE:TMP2, NODE:TMP2, TMP1 // node = tab->node + (idx*32-idx*8)
4807 |1:
4808 | lwz CARG1, NODE:TMP2->key
4809 | lwz TMP0, 4+offsetof(Node, key)(NODE:TMP2)
4810 | lwz CARG2, NODE:TMP2->val
4811 | lwz NODE:TMP1, NODE:TMP2->next
4812 | checkstr CARG1; bne >5
4813 | cmpw TMP0, STR:RC; bne >5
4814 | checknil CARG2; beq >4 // Key found, but nil value?
4815 |2:
4816 | andix. TMP0, TMP3, LJ_GC_BLACK // isblack(table)
4817 |.if FPU
4818 | stfd f14, NODE:TMP2->val
4819 |.else
4820 | stw SAVE0, NODE:TMP2->val.u32.hi
4821 | stw SAVE1, NODE:TMP2->val.u32.lo
4822 |.endif
4823 | bne >7
4824 |3:
4825 | ins_next
4826 |
4827 |4: // Check for __newindex if previous value is nil.
4828 | lwz TAB:TMP1, TAB:RB->metatable
4829 | cmplwi TAB:TMP1, 0
4830 | beq <2 // No metatable: done.
4831 | lbz TMP0, TAB:TMP1->nomm
4832 | andix. TMP0, TMP0, 1<<MM_newindex
4833 | bne <2 // 'no __newindex' flag set: done.
4834 | b ->vmeta_tsets
4835 |
4836 |5: // Follow hash chain.
4837 | cmplwi NODE:TMP1, 0
4838 | mr NODE:TMP2, NODE:TMP1
4839 | bne <1
4840 | // End of hash chain: key not found, add a new one.
4841 |
4842 | // But check for __newindex first.
4843 | lwz TAB:TMP1, TAB:RB->metatable
4844 | la CARG3, DISPATCH_GL(tmptv)(DISPATCH)
4845 | stw PC, SAVE_PC
4846 | mr CARG1, L
4847 | cmplwi TAB:TMP1, 0
4848 | stp BASE, L->base
4849 | beq >6 // No metatable: continue.
4850 | lbz TMP0, TAB:TMP1->nomm
4851 | andix. TMP0, TMP0, 1<<MM_newindex
4852 | beq ->vmeta_tsets // 'no __newindex' flag NOT set: check.
4853 |6:
4854 | li TMP0, LJ_TSTR
4855 | stw STR:RC, 4(CARG3)
4856 | mr CARG2, TAB:RB
4857 | stw TMP0, 0(CARG3)
4858 | bl extern lj_tab_newkey // (lua_State *L, GCtab *t, TValue *k)
4859 | // Returns TValue *.
4860 | lp BASE, L->base
4861 |.if FPU
4862 | stfd f14, 0(CRET1)
4863 |.else
4864 | stw SAVE0, 0(CRET1)
4865 | stw SAVE1, 4(CRET1)
4866 |.endif
4867 | b <3 // No 2nd write barrier needed.
4868 |
4869 |7: // Possible table write barrier for the value. Skip valiswhite check.
4870 | barrierback TAB:RB, TMP3, TMP0
4871 | b <3
4872 break;
4873 case BC_TSETB:
4874 | // RA = src*8, RB = table*8, RC = index*8
4875 | lwzux CARG1, RB, BASE
4876 | srwi TMP0, RC, 3
4877 | lwz TAB:RB, 4(RB)
4878 | checktab CARG1; bne ->vmeta_tsetb
4879 | lwz TMP1, TAB:RB->asize
4880 | lwz TMP2, TAB:RB->array
4881 | lbz TMP3, TAB:RB->marked
4882 | cmplw TMP0, TMP1
4883 |.if FPU
4884 | lfdx f14, BASE, RA
4885 |.else
4886 | add CARG2, BASE, RA
4887 | lwz SAVE0, 0(CARG2)
4888 | lwz SAVE1, 4(CARG2)
4889 |.endif
4890 | bge ->vmeta_tsetb
4891 | lwzx TMP1, TMP2, RC
4892 | checknil TMP1; beq >5
4893 |1:
4894 | andix. TMP0, TMP3, LJ_GC_BLACK // isblack(table)
4895 |.if FPU
4896 | stfdx f14, TMP2, RC
4897 |.else
4898 | stwux SAVE0, RC, TMP2
4899 | stw SAVE1, 4(RC)
4900 |.endif
4901 | bne >7
4902 |2:
4903 | ins_next
4904 |
4905 |5: // Check for __newindex if previous value is nil.
4906 | lwz TAB:TMP1, TAB:RB->metatable
4907 | cmplwi TAB:TMP1, 0
4908 | beq <1 // No metatable: done.
4909 | lbz TMP1, TAB:TMP1->nomm
4910 | andix. TMP1, TMP1, 1<<MM_newindex
4911 | bne <1 // 'no __newindex' flag set: done.
4912 | b ->vmeta_tsetb // Caveat: preserve TMP0!
4913 |
4914 |7: // Possible table write barrier for the value. Skip valiswhite check.
4915 | barrierback TAB:RB, TMP3, TMP0
4916 | b <2
4917 break;
4918 case BC_TSETR:
4919 | // RA = dst*8, RB = table*8, RC = key*8
4920 | add RB, BASE, RB
4921 | lwz TAB:CARG2, 4(RB)
4922 |.if DUALNUM
4923 | add RC, BASE, RC
4924 | lbz TMP3, TAB:CARG2->marked
4925 | lwz TMP0, TAB:CARG2->asize
4926 | lwz CARG3, 4(RC)
4927 | lwz TMP1, TAB:CARG2->array
4928 |.else
4929 | lfdx f0, BASE, RC
4930 | lbz TMP3, TAB:CARG2->marked
4931 | lwz TMP0, TAB:CARG2->asize
4932 | toint CARG3, f0
4933 | lwz TMP1, TAB:CARG2->array
4934 |.endif
4935 | andix. TMP2, TMP3, LJ_GC_BLACK // isblack(table)
4936 | bne >7
4937 |2:
4938 | cmplw TMP0, CARG3
4939 | slwi TMP2, CARG3, 3
4940 |.if FPU
4941 | lfdx f14, BASE, RA
4942 |.else
4943 | lwzux SAVE0, RA, BASE
4944 | lwz SAVE1, 4(RA)
4945 |.endif
4946 | ble ->vmeta_tsetr // In array part?
4947 | ins_next1
4948 |.if FPU
4949 | stfdx f14, TMP1, TMP2
4950 |.else
4951 | stwux SAVE0, TMP1, TMP2
4952 | stw SAVE1, 4(TMP1)
4953 |.endif
4954 | ins_next2
4955 |
4956 |7: // Possible table write barrier for the value. Skip valiswhite check.
4957 | barrierback TAB:CARG2, TMP3, TMP2
4958 | b <2
4959 break;
4960
4961
4962 case BC_TSETM:
4963 | // RA = base*8 (table at base-1), RD = num_const*8 (start index)
4964 | add RA, BASE, RA
4965 |1:
4966 | add TMP3, KBASE, RD
4967 | lwz TAB:CARG2, -4(RA) // Guaranteed to be a table.
4968 | addic. TMP0, MULTRES, -8
4969 | lwz TMP3, 4(TMP3) // Integer constant is in lo-word.
4970 | srwi CARG3, TMP0, 3
4971 | beq >4 // Nothing to copy?
4972 | add CARG3, CARG3, TMP3
4973 | lwz TMP2, TAB:CARG2->asize
4974 | slwi TMP1, TMP3, 3
4975 | lbz TMP3, TAB:CARG2->marked
4976 | cmplw CARG3, TMP2
4977 | add TMP2, RA, TMP0
4978 | lwz TMP0, TAB:CARG2->array
4979 | bgt >5
4980 | add TMP1, TMP1, TMP0
4981 | andix. TMP0, TMP3, LJ_GC_BLACK // isblack(table)
4982 |3: // Copy result slots to table.
4983 |.if FPU
4984 | lfd f0, 0(RA)
4985 |.else
4986 | lwz SAVE0, 0(RA)
4987 | lwz SAVE1, 4(RA)
4988 |.endif
4989 | addi RA, RA, 8
4990 | cmpw cr1, RA, TMP2
4991 |.if FPU
4992 | stfd f0, 0(TMP1)
4993 |.else
4994 | stw SAVE0, 0(TMP1)
4995 | stw SAVE1, 4(TMP1)
4996 |.endif
4997 | addi TMP1, TMP1, 8
4998 | blt cr1, <3
4999 | bne >7
5000 |4:
5001 | ins_next
5002 |
5003 |5: // Need to resize array part.
5004 | stp BASE, L->base
5005 | mr CARG1, L
5006 | stw PC, SAVE_PC
5007 | mr SAVE0, RD
5008 | bl extern lj_tab_reasize // (lua_State *L, GCtab *t, int nasize)
5009 | // Must not reallocate the stack.
5010 | mr RD, SAVE0
5011 | b <1
5012 |
5013 |7: // Possible table write barrier for any value. Skip valiswhite check.
5014 | barrierback TAB:CARG2, TMP3, TMP0
5015 | b <4
5016 break;
5017
5018 /* -- Calls and vararg handling ----------------------------------------- */
5019
5020 case BC_CALLM:
5021 | // RA = base*8, (RB = (nresults+1)*8,) RC = extra_nargs*8
5022 | add NARGS8:RC, NARGS8:RC, MULTRES
5023 | // Fall through. Assumes BC_CALL follows.
5024 break;
5025 case BC_CALL:
5026 | // RA = base*8, (RB = (nresults+1)*8,) RC = (nargs+1)*8
5027 | mr TMP2, BASE
5028 | lwzux TMP0, BASE, RA
5029 | lwz LFUNC:RB, 4(BASE)
5030 | subi NARGS8:RC, NARGS8:RC, 8
5031 | addi BASE, BASE, 8
5032 | checkfunc TMP0; bne ->vmeta_call
5033 | ins_call
5034 break;
5035
5036 case BC_CALLMT:
5037 | // RA = base*8, (RB = 0,) RC = extra_nargs*8
5038 | add NARGS8:RC, NARGS8:RC, MULTRES
5039 | // Fall through. Assumes BC_CALLT follows.
5040 break;
5041 case BC_CALLT:
5042 | // RA = base*8, (RB = 0,) RC = (nargs+1)*8
5043 | lwzux TMP0, RA, BASE
5044 | lwz LFUNC:RB, 4(RA)
5045 | subi NARGS8:RC, NARGS8:RC, 8
5046 | lwz TMP1, FRAME_PC(BASE)
5047 | checkfunc TMP0
5048 | addi RA, RA, 8
5049 | bne ->vmeta_callt
5050 |->BC_CALLT_Z:
5051 | andix. TMP0, TMP1, FRAME_TYPE // Caveat: preserve cr0 until the crand.
5052 | lbz TMP3, LFUNC:RB->ffid
5053 | xori TMP2, TMP1, FRAME_VARG
5054 | cmplwi cr1, NARGS8:RC, 0
5055 | bne >7
5056 |1:
5057 | stw LFUNC:RB, FRAME_FUNC(BASE) // Copy function down, but keep PC.
5058 | li TMP2, 0
5059 | cmplwi cr7, TMP3, 1 // (> FF_C) Calling a fast function?
5060 | beq cr1, >3
5061 |2:
5062 | addi TMP3, TMP2, 8
5063 |.if FPU
5064 | lfdx f0, RA, TMP2
5065 |.else
5066 | add CARG3, RA, TMP2
5067 | lwz CARG1, 0(CARG3)
5068 | lwz CARG2, 4(CARG3)
5069 |.endif
5070 | cmplw cr1, TMP3, NARGS8:RC
5071 |.if FPU
5072 | stfdx f0, BASE, TMP2
5073 |.else
5074 | stwux CARG1, TMP2, BASE
5075 | stw CARG2, 4(TMP2)
5076 |.endif
5077 | mr TMP2, TMP3
5078 | bne cr1, <2
5079 |3:
5080 | crand 4*cr0+eq, 4*cr0+eq, 4*cr7+gt
5081 | beq >5
5082 |4:
5083 | ins_callt
5084 |
5085 |5: // Tailcall to a fast function with a Lua frame below.
5086 | lwz INS, -4(TMP1)
5087 | decode_RA8 RA, INS
5088 | sub TMP1, BASE, RA
5089 | lwz LFUNC:TMP1, FRAME_FUNC-8(TMP1)
5090 | lwz TMP1, LFUNC:TMP1->pc
5091 | lwz KBASE, PC2PROTO(k)(TMP1) // Need to prepare KBASE.
5092 | b <4
5093 |
5094 |7: // Tailcall from a vararg function.
5095 | andix. TMP0, TMP2, FRAME_TYPEP
5096 | bne <1 // Vararg frame below?
5097 | sub BASE, BASE, TMP2 // Relocate BASE down.
5098 | lwz TMP1, FRAME_PC(BASE)
5099 | andix. TMP0, TMP1, FRAME_TYPE
5100 | b <1
5101 break;
5102
5103 case BC_ITERC:
5104 | // RA = base*8, (RB = (nresults+1)*8, RC = (nargs+1)*8 ((2+1)*8))
5105 | mr TMP2, BASE
5106 | add BASE, BASE, RA
5107 | lwz TMP1, -24(BASE)
5108 | lwz LFUNC:RB, -20(BASE)
5109 |.if FPU
5110 | lfd f1, -8(BASE)
5111 | lfd f0, -16(BASE)
5112 |.else
5113 | lwz CARG1, -8(BASE)
5114 | lwz CARG2, -4(BASE)
5115 | lwz CARG3, -16(BASE)
5116 | lwz CARG4, -12(BASE)
5117 |.endif
5118 | stw TMP1, 0(BASE) // Copy callable.
5119 | stw LFUNC:RB, 4(BASE)
5120 | checkfunc TMP1
5121 | li NARGS8:RC, 16 // Iterators get 2 arguments.
5122 |.if FPU
5123 | stfd f1, 16(BASE) // Copy control var.
5124 | stfdu f0, 8(BASE) // Copy state.
5125 |.else
5126 | stw CARG1, 16(BASE) // Copy control var.
5127 | stw CARG2, 20(BASE)
5128 | stwu CARG3, 8(BASE) // Copy state.
5129 | stw CARG4, 4(BASE)
5130 |.endif
5131 | bne ->vmeta_call
5132 | ins_call
5133 break;
5134
5135 case BC_ITERN:
5136 | // RA = base*8, (RB = (nresults+1)*8, RC = (nargs+1)*8 (2+1)*8)
5137 |.if JIT
5138 | // NYI on big-endian
5139 |.endif
5140 |->vm_IITERN:
5141 | add RA, BASE, RA
5142 | lwz TAB:RB, -12(RA)
5143 | lwz RC, -4(RA) // Get index from control var.
5144 | lwz TMP0, TAB:RB->asize
5145 | lwz TMP1, TAB:RB->array
5146 | addi PC, PC, 4
5147 |1: // Traverse array part.
5148 | cmplw RC, TMP0
5149 | slwi TMP3, RC, 3
5150 | bge >5 // Index points after array part?
5151 | lwzx TMP2, TMP1, TMP3
5152 |.if FPU
5153 | lfdx f0, TMP1, TMP3
5154 |.else
5155 | lwzux CARG1, TMP3, TMP1
5156 | lwz CARG2, 4(TMP3)
5157 |.endif
5158 | checknil TMP2
5159 | lwz INS, -4(PC)
5160 | beq >4
5161 |.if DUALNUM
5162 | stw RC, 4(RA)
5163 | stw TISNUM, 0(RA)
5164 |.else
5165 | tonum_u f1, RC
5166 |.endif
5167 | addi RC, RC, 1
5168 | addis TMP3, PC, -(BCBIAS_J*4 >> 16)
5169 |.if FPU
5170 | stfd f0, 8(RA)
5171 |.else
5172 | stw CARG1, 8(RA)
5173 | stw CARG2, 12(RA)
5174 |.endif
5175 | decode_RD4 TMP1, INS
5176 | stw RC, -4(RA) // Update control var.
5177 | add PC, TMP1, TMP3
5178 |.if not DUALNUM
5179 | stfd f1, 0(RA)
5180 |.endif
5181 |3:
5182 | ins_next
5183 |
5184 |4: // Skip holes in array part.
5185 | addi RC, RC, 1
5186 | b <1
5187 |
5188 |5: // Traverse hash part.
5189 | lwz TMP1, TAB:RB->hmask
5190 | sub RC, RC, TMP0
5191 | lwz TMP2, TAB:RB->node
5192 |6:
5193 | cmplw RC, TMP1 // End of iteration? Branch to ITERL+1.
5194 | slwi TMP3, RC, 5
5195 | bgty <3
5196 | slwi RB, RC, 3
5197 | sub TMP3, TMP3, RB
5198 | lwzx RB, TMP2, TMP3
5199 |.if FPU
5200 | lfdx f0, TMP2, TMP3
5201 |.else
5202 | add CARG3, TMP2, TMP3
5203 | lwz CARG1, 0(CARG3)
5204 | lwz CARG2, 4(CARG3)
5205 |.endif
5206 | add NODE:TMP3, TMP2, TMP3
5207 | checknil RB
5208 | lwz INS, -4(PC)
5209 | beq >7
5210 |.if FPU
5211 | lfd f1, NODE:TMP3->key
5212 |.else
5213 | lwz CARG3, NODE:TMP3->key.u32.hi
5214 | lwz CARG4, NODE:TMP3->key.u32.lo
5215 |.endif
5216 | addis TMP2, PC, -(BCBIAS_J*4 >> 16)
5217 |.if FPU
5218 | stfd f0, 8(RA)
5219 |.else
5220 | stw CARG1, 8(RA)
5221 | stw CARG2, 12(RA)
5222 |.endif
5223 | add RC, RC, TMP0
5224 | decode_RD4 TMP1, INS
5225 |.if FPU
5226 | stfd f1, 0(RA)
5227 |.else
5228 | stw CARG3, 0(RA)
5229 | stw CARG4, 4(RA)
5230 |.endif
5231 | addi RC, RC, 1
5232 | add PC, TMP1, TMP2
5233 | stw RC, -4(RA) // Update control var.
5234 | b <3
5235 |
5236 |7: // Skip holes in hash part.
5237 | addi RC, RC, 1
5238 | b <6
5239 break;
5240
5241 case BC_ISNEXT:
5242 | // RA = base*8, RD = target (points to ITERN)
5243 | add RA, BASE, RA
5244 | lwz TMP0, -24(RA)
5245 | lwz CFUNC:TMP1, -20(RA)
5246 | lwz TMP2, -16(RA)
5247 | lwz TMP3, -8(RA)
5248 | cmpwi cr0, TMP2, LJ_TTAB
5249 | cmpwi cr1, TMP0, LJ_TFUNC
5250 | cmpwi cr6, TMP3, LJ_TNIL
5251 | bne cr1, >5
5252 | lbz TMP1, CFUNC:TMP1->ffid
5253 | crand 4*cr0+eq, 4*cr0+eq, 4*cr6+eq
5254 | cmpwi cr7, TMP1, FF_next_N
5255 | srwi TMP0, RD, 1
5256 | crand 4*cr0+eq, 4*cr0+eq, 4*cr7+eq
5257 | add TMP3, PC, TMP0
5258 | bne cr0, >5
5259 | lus TMP1, (LJ_KEYINDEX >> 16)
5260 | ori TMP1, TMP1, (LJ_KEYINDEX & 0xffff)
5261 | stw ZERO, -4(RA) // Initialize control var.
5262 | stw TMP1, -8(RA)
5263 | addis PC, TMP3, -(BCBIAS_J*4 >> 16)
5264 |1:
5265 | ins_next
5266 |5: // Despecialize bytecode if any of the checks fail.
5267 | li TMP0, BC_JMP
5268 | li TMP1, BC_ITERC
5269 | stb TMP0, -1(PC)
5270 | addis PC, TMP3, -(BCBIAS_J*4 >> 16)
5271 | // NYI on big-endian: unpatch JLOOP.
5272 | stb TMP1, 3(PC)
5273 | b <1
5274 break;
5275
5276 case BC_VARG:
5277 | // RA = base*8, RB = (nresults+1)*8, RC = numparams*8
5278 | lwz TMP0, FRAME_PC(BASE)
5279 | add RC, BASE, RC
5280 | add RA, BASE, RA
5281 | addi RC, RC, FRAME_VARG
5282 | add TMP2, RA, RB
5283 | subi TMP3, BASE, 8 // TMP3 = vtop
5284 | sub RC, RC, TMP0 // RC = vbase
5285 | // Note: RC may now be even _above_ BASE if nargs was < numparams.
5286 | cmplwi cr1, RB, 0
5287 |.if PPE
5288 | sub TMP1, TMP3, RC
5289 | cmpwi TMP1, 0
5290 |.else
5291 | sub. TMP1, TMP3, RC
5292 |.endif
5293 | beq cr1, >5 // Copy all varargs?
5294 | subi TMP2, TMP2, 16
5295 | ble >2 // No vararg slots?
5296 |1: // Copy vararg slots to destination slots.
5297 |.if FPU
5298 | lfd f0, 0(RC)
5299 |.else
5300 | lwz CARG1, 0(RC)
5301 | lwz CARG2, 4(RC)
5302 |.endif
5303 | addi RC, RC, 8
5304 |.if FPU
5305 | stfd f0, 0(RA)
5306 |.else
5307 | stw CARG1, 0(RA)
5308 | stw CARG2, 4(RA)
5309 |.endif
5310 | cmplw RA, TMP2
5311 | cmplw cr1, RC, TMP3
5312 | bge >3 // All destination slots filled?
5313 | addi RA, RA, 8
5314 | blt cr1, <1 // More vararg slots?
5315 |2: // Fill up remainder with nil.
5316 | stw TISNIL, 0(RA)
5317 | cmplw RA, TMP2
5318 | addi RA, RA, 8
5319 | blt <2
5320 |3:
5321 | ins_next
5322 |
5323 |5: // Copy all varargs.
5324 | lwz TMP0, L->maxstack
5325 | li MULTRES, 8 // MULTRES = (0+1)*8
5326 | bley <3 // No vararg slots?
5327 | add TMP2, RA, TMP1
5328 | cmplw TMP2, TMP0
5329 | addi MULTRES, TMP1, 8
5330 | bgt >7
5331 |6:
5332 |.if FPU
5333 | lfd f0, 0(RC)
5334 |.else
5335 | lwz CARG1, 0(RC)
5336 | lwz CARG2, 4(RC)
5337 |.endif
5338 | addi RC, RC, 8
5339 |.if FPU
5340 | stfd f0, 0(RA)
5341 |.else
5342 | stw CARG1, 0(RA)
5343 | stw CARG2, 4(RA)
5344 |.endif
5345 | cmplw RC, TMP3
5346 | addi RA, RA, 8
5347 | blt <6 // More vararg slots?
5348 | b <3
5349 |
5350 |7: // Grow stack for varargs.
5351 | mr CARG1, L
5352 | stp RA, L->top
5353 | sub SAVE0, RC, BASE // Need delta, because BASE may change.
5354 | stp BASE, L->base
5355 | sub RA, RA, BASE
5356 | stw PC, SAVE_PC
5357 | srwi CARG2, TMP1, 3
5358 | bl extern lj_state_growstack // (lua_State *L, int n)
5359 | lp BASE, L->base
5360 | add RA, BASE, RA
5361 | add RC, BASE, SAVE0
5362 | subi TMP3, BASE, 8
5363 | b <6
5364 break;
5365
5366 /* -- Returns ----------------------------------------------------------- */
5367
5368 case BC_RETM:
5369 | // RA = results*8, RD = extra_nresults*8
5370 | add RD, RD, MULTRES // MULTRES >= 8, so RD >= 8.
5371 | // Fall through. Assumes BC_RET follows.
5372 break;
5373
5374 case BC_RET:
5375 | // RA = results*8, RD = (nresults+1)*8
5376 | lwz PC, FRAME_PC(BASE)
5377 | add RA, BASE, RA
5378 | mr MULTRES, RD
5379 |1:
5380 | andix. TMP0, PC, FRAME_TYPE
5381 | xori TMP1, PC, FRAME_VARG
5382 | bne ->BC_RETV_Z
5383 |
5384 |->BC_RET_Z:
5385 | // BASE = base, RA = resultptr, RD = (nresults+1)*8, PC = return
5386 | lwz INS, -4(PC)
5387 | cmpwi RD, 8
5388 | subi TMP2, BASE, 8
5389 | subi RC, RD, 8
5390 | decode_RB8 RB, INS
5391 | beq >3
5392 | li TMP1, 0
5393 |2:
5394 | addi TMP3, TMP1, 8
5395 |.if FPU
5396 | lfdx f0, RA, TMP1
5397 |.else
5398 | add CARG3, RA, TMP1
5399 | lwz CARG1, 0(CARG3)
5400 | lwz CARG2, 4(CARG3)
5401 |.endif
5402 | cmpw TMP3, RC
5403 |.if FPU
5404 | stfdx f0, TMP2, TMP1
5405 |.else
5406 | add CARG3, TMP2, TMP1
5407 | stw CARG1, 0(CARG3)
5408 | stw CARG2, 4(CARG3)
5409 |.endif
5410 | beq >3
5411 | addi TMP1, TMP3, 8
5412 |.if FPU
5413 | lfdx f1, RA, TMP3
5414 |.else
5415 | add CARG3, RA, TMP3
5416 | lwz CARG1, 0(CARG3)
5417 | lwz CARG2, 4(CARG3)
5418 |.endif
5419 | cmpw TMP1, RC
5420 |.if FPU
5421 | stfdx f1, TMP2, TMP3
5422 |.else
5423 | add CARG3, TMP2, TMP3
5424 | stw CARG1, 0(CARG3)
5425 | stw CARG2, 4(CARG3)
5426 |.endif
5427 | bne <2
5428 |3:
5429 |5:
5430 | cmplw RB, RD
5431 | decode_RA8 RA, INS
5432 | bgt >6
5433 | sub BASE, TMP2, RA
5434 | lwz LFUNC:TMP1, FRAME_FUNC(BASE)
5435 | ins_next1
5436 | lwz TMP1, LFUNC:TMP1->pc
5437 | lwz KBASE, PC2PROTO(k)(TMP1)
5438 | ins_next2
5439 |
5440 |6: // Fill up results with nil.
5441 | subi TMP1, RD, 8
5442 | addi RD, RD, 8
5443 | stwx TISNIL, TMP2, TMP1
5444 | b <5
5445 |
5446 |->BC_RETV_Z: // Non-standard return case.
5447 | andix. TMP2, TMP1, FRAME_TYPEP
5448 | bne ->vm_return
5449 | // Return from vararg function: relocate BASE down.
5450 | sub BASE, BASE, TMP1
5451 | lwz PC, FRAME_PC(BASE)
5452 | b <1
5453 break;
5454
5455 case BC_RET0: case BC_RET1:
5456 | // RA = results*8, RD = (nresults+1)*8
5457 | lwz PC, FRAME_PC(BASE)
5458 | add RA, BASE, RA
5459 | mr MULTRES, RD
5460 | andix. TMP0, PC, FRAME_TYPE
5461 | xori TMP1, PC, FRAME_VARG
5462 | bney ->BC_RETV_Z
5463 |
5464 | lwz INS, -4(PC)
5465 | subi TMP2, BASE, 8
5466 | decode_RB8 RB, INS
5467 if (op == BC_RET1) {
5468 |.if FPU
5469 | lfd f0, 0(RA)
5470 | stfd f0, 0(TMP2)
5471 |.else
5472 | lwz CARG1, 0(RA)
5473 | lwz CARG2, 4(RA)
5474 | stw CARG1, 0(TMP2)
5475 | stw CARG2, 4(TMP2)
5476 |.endif
5477 }
5478 |5:
5479 | cmplw RB, RD
5480 | decode_RA8 RA, INS
5481 | bgt >6
5482 | sub BASE, TMP2, RA
5483 | lwz LFUNC:TMP1, FRAME_FUNC(BASE)
5484 | ins_next1
5485 | lwz TMP1, LFUNC:TMP1->pc
5486 | lwz KBASE, PC2PROTO(k)(TMP1)
5487 | ins_next2
5488 |
5489 |6: // Fill up results with nil.
5490 | subi TMP1, RD, 8
5491 | addi RD, RD, 8
5492 | stwx TISNIL, TMP2, TMP1
5493 | b <5
5494 break;
5495
5496 /* -- Loops and branches ------------------------------------------------ */
5497
5498 case BC_FORL:
5499 |.if JIT
5500 | hotloop
5501 |.endif
5502 | // Fall through. Assumes BC_IFORL follows.
5503 break;
5504
5505 case BC_JFORI:
5506 case BC_JFORL:
5507 #if !LJ_HASJIT
5508 break;
5509 #endif
5510 case BC_FORI:
5511 case BC_IFORL:
5512 | // RA = base*8, RD = target (after end of loop or start of loop)
5513 vk = (op == BC_IFORL || op == BC_JFORL);
5514 |.if DUALNUM
5515 | // Integer loop.
5516 | lwzux TMP1, RA, BASE
5517 | lwz CARG1, FORL_IDX*8+4(RA)
5518 | cmplw cr0, TMP1, TISNUM
5519 if (vk) {
5520 | lwz CARG3, FORL_STEP*8+4(RA)
5521 | bne >9
5522 |.if GPR64
5523 | // Need to check overflow for (a<<32) + (b<<32).
5524 | rldicr TMP0, CARG1, 32, 31
5525 | rldicr TMP2, CARG3, 32, 31
5526 | add CARG1, CARG1, CARG3
5527 | addo. TMP0, TMP0, TMP2
5528 |.else
5529 | addo. CARG1, CARG1, CARG3
5530 |.endif
5531 | cmpwi cr6, CARG3, 0
5532 | lwz CARG2, FORL_STOP*8+4(RA)
5533 | bso >6
5534 |4:
5535 | stw CARG1, FORL_IDX*8+4(RA)
5536 } else {
5537 | lwz SAVE0, FORL_STEP*8(RA)
5538 | lwz CARG3, FORL_STEP*8+4(RA)
5539 | lwz TMP2, FORL_STOP*8(RA)
5540 | lwz CARG2, FORL_STOP*8+4(RA)
5541 | cmplw cr7, SAVE0, TISNUM
5542 | cmplw cr1, TMP2, TISNUM
5543 | crand 4*cr0+eq, 4*cr0+eq, 4*cr7+eq
5544 | crand 4*cr0+eq, 4*cr0+eq, 4*cr1+eq
5545 | cmpwi cr6, CARG3, 0
5546 | bne >9
5547 }
5548 | blt cr6, >5
5549 | cmpw CARG1, CARG2
5550 |1:
5551 | stw TISNUM, FORL_EXT*8(RA)
5552 if (op != BC_JFORL) {
5553 | srwi RD, RD, 1
5554 }
5555 | stw CARG1, FORL_EXT*8+4(RA)
5556 if (op != BC_JFORL) {
5557 | add RD, PC, RD
5558 }
5559 if (op == BC_FORI) {
5560 | bgt >3 // See FP loop below.
5561 } else if (op == BC_JFORI) {
5562 | addis PC, RD, -(BCBIAS_J*4 >> 16)
5563 | bley >7
5564 } else if (op == BC_IFORL) {
5565 | bgt >2
5566 | addis PC, RD, -(BCBIAS_J*4 >> 16)
5567 } else {
5568 | bley =>BC_JLOOP
5569 }
5570 |2:
5571 | ins_next
5572 |5: // Invert check for negative step.
5573 | cmpw CARG2, CARG1
5574 | b <1
5575 if (vk) {
5576 |6: // Potential overflow.
5577 | checkov TMP0, <4 // Ignore unrelated overflow.
5578 | b <2
5579 }
5580 |.endif
5581 if (vk) {
5582 |.if DUALNUM
5583 |9: // FP loop.
5584 |.if FPU
5585 | lfd f1, FORL_IDX*8(RA)
5586 |.else
5587 | lwz CARG1, FORL_IDX*8(RA)
5588 | lwz CARG2, FORL_IDX*8+4(RA)
5589 |.endif
5590 |.else
5591 | lfdux f1, RA, BASE
5592 |.endif
5593 |.if FPU
5594 | lfd f3, FORL_STEP*8(RA)
5595 | lfd f2, FORL_STOP*8(RA)
5596 | fadd f1, f1, f3
5597 | stfd f1, FORL_IDX*8(RA)
5598 |.else
5599 | lwz CARG3, FORL_STEP*8(RA)
5600 | lwz CARG4, FORL_STEP*8+4(RA)
5601 | mr SAVE1, RD
5602 | blex __adddf3
5603 | mr RD, SAVE1
5604 | stw CRET1, FORL_IDX*8(RA)
5605 | stw CRET2, FORL_IDX*8+4(RA)
5606 | lwz CARG3, FORL_STOP*8(RA)
5607 | lwz CARG4, FORL_STOP*8+4(RA)
5608 |.endif
5609 | lwz SAVE0, FORL_STEP*8(RA)
5610 } else {
5611 |.if DUALNUM
5612 |9: // FP loop.
5613 |.else
5614 | lwzux TMP1, RA, BASE
5615 | lwz SAVE0, FORL_STEP*8(RA)
5616 | lwz TMP2, FORL_STOP*8(RA)
5617 | cmplw cr0, TMP1, TISNUM
5618 | cmplw cr7, SAVE0, TISNUM
5619 | cmplw cr1, TMP2, TISNUM
5620 |.endif
5621 |.if FPU
5622 | lfd f1, FORL_IDX*8(RA)
5623 |.else
5624 | lwz CARG1, FORL_IDX*8(RA)
5625 | lwz CARG2, FORL_IDX*8+4(RA)
5626 |.endif
5627 | crand 4*cr0+lt, 4*cr0+lt, 4*cr7+lt
5628 | crand 4*cr0+lt, 4*cr0+lt, 4*cr1+lt
5629 |.if FPU
5630 | lfd f2, FORL_STOP*8(RA)
5631 |.else
5632 | lwz CARG3, FORL_STOP*8(RA)
5633 | lwz CARG4, FORL_STOP*8+4(RA)
5634 |.endif
5635 | bge ->vmeta_for
5636 }
5637 | cmpwi cr6, SAVE0, 0
5638 if (op != BC_JFORL) {
5639 | srwi RD, RD, 1
5640 }
5641 |.if FPU
5642 | stfd f1, FORL_EXT*8(RA)
5643 |.else
5644 | stw CARG1, FORL_EXT*8(RA)
5645 | stw CARG2, FORL_EXT*8+4(RA)
5646 |.endif
5647 if (op != BC_JFORL) {
5648 | add RD, PC, RD
5649 }
5650 |.if FPU
5651 | fcmpu cr0, f1, f2
5652 |.else
5653 | mr SAVE1, RD
5654 | blex __ledf2
5655 | cmpwi CRET1, 0
5656 | mr RD, SAVE1
5657 |.endif
5658 if (op == BC_JFORI) {
5659 | addis PC, RD, -(BCBIAS_J*4 >> 16)
5660 }
5661 | blt cr6, >5
5662 if (op == BC_FORI) {
5663 | bgt >3
5664 } else if (op == BC_IFORL) {
5665 |.if DUALNUM
5666 | bgty <2
5667 |.else
5668 | bgt >2
5669 |.endif
5670 |1:
5671 | addis PC, RD, -(BCBIAS_J*4 >> 16)
5672 } else if (op == BC_JFORI) {
5673 | bley >7
5674 } else {
5675 | bley =>BC_JLOOP
5676 }
5677 |.if DUALNUM
5678 | b <2
5679 |.else
5680 |2:
5681 | ins_next
5682 |.endif
5683 |5: // Negative step.
5684 if (op == BC_FORI) {
5685 | bge <2
5686 |3: // Used by integer loop, too.
5687 | addis PC, RD, -(BCBIAS_J*4 >> 16)
5688 } else if (op == BC_IFORL) {
5689 | bgey <1
5690 } else if (op == BC_JFORI) {
5691 | bgey >7
5692 } else {
5693 | bgey =>BC_JLOOP
5694 }
5695 | b <2
5696 if (op == BC_JFORI) {
5697 |7:
5698 | lwz INS, -4(PC)
5699 | decode_RD8 RD, INS
5700 | b =>BC_JLOOP
5701 }
5702 break;
5703
5704 case BC_ITERL:
5705 |.if JIT
5706 | hotloop
5707 |.endif
5708 | // Fall through. Assumes BC_IITERL follows.
5709 break;
5710
5711 case BC_JITERL:
5712 #if !LJ_HASJIT
5713 break;
5714 #endif
5715 case BC_IITERL:
5716 | // RA = base*8, RD = target
5717 | lwzux TMP1, RA, BASE
5718 | lwz TMP2, 4(RA)
5719 | checknil TMP1; beq >1 // Stop if iterator returned nil.
5720 if (op == BC_JITERL) {
5721 | stw TMP1, -8(RA)
5722 | stw TMP2, -4(RA)
5723 | b =>BC_JLOOP
5724 } else {
5725 | branch_RD // Otherwise save control var + branch.
5726 | stw TMP1, -8(RA)
5727 | stw TMP2, -4(RA)
5728 }
5729 |1:
5730 | ins_next
5731 break;
5732
5733 case BC_LOOP:
5734 | // RA = base*8, RD = target (loop extent)
5735 | // Note: RA/RD is only used by trace recorder to determine scope/extent
5736 | // This opcode does NOT jump, it's only purpose is to detect a hot loop.
5737 |.if JIT
5738 | hotloop
5739 |.endif
5740 | // Fall through. Assumes BC_ILOOP follows.
5741 break;
5742
5743 case BC_ILOOP:
5744 | // RA = base*8, RD = target (loop extent)
5745 | ins_next
5746 break;
5747
5748 case BC_JLOOP:
5749 |.if JIT
5750 | // RA = base*8 (ignored), RD = traceno*8
5751 | lwz TMP1, DISPATCH_J(trace)(DISPATCH)
5752 | srwi RD, RD, 1
5753 | // Traces on PPC don't store the trace number, so use 0.
5754 | stw ZERO, DISPATCH_GL(vmstate)(DISPATCH)
5755 | lwzx TRACE:TMP2, TMP1, RD
5756 | clrso TMP1
5757 | lp TMP2, TRACE:TMP2->mcode
5758 | stw BASE, DISPATCH_GL(jit_base)(DISPATCH)
5759 | mtctr TMP2
5760 | addi JGL, DISPATCH, GG_DISP2G+32768
5761 | stw L, DISPATCH_GL(tmpbuf.L)(DISPATCH)
5762 | bctr
5763 |.endif
5764 break;
5765
5766 case BC_JMP:
5767 | // RA = base*8 (only used by trace recorder), RD = target
5768 | branch_RD
5769 | ins_next
5770 break;
5771
5772 /* -- Function headers -------------------------------------------------- */
5773
5774 case BC_FUNCF:
5775 |.if JIT
5776 | hotcall
5777 |.endif
5778 case BC_FUNCV: /* NYI: compiled vararg functions. */
5779 | // Fall through. Assumes BC_IFUNCF/BC_IFUNCV follow.
5780 break;
5781
5782 case BC_JFUNCF:
5783 #if !LJ_HASJIT
5784 break;
5785 #endif
5786 case BC_IFUNCF:
5787 | // BASE = new base, RA = BASE+framesize*8, RB = LFUNC, RC = nargs*8
5788 | lwz TMP2, L->maxstack
5789 | lbz TMP1, -4+PC2PROTO(numparams)(PC)
5790 | lwz KBASE, -4+PC2PROTO(k)(PC)
5791 | cmplw RA, TMP2
5792 | slwi TMP1, TMP1, 3
5793 | bgt ->vm_growstack_l
5794 if (op != BC_JFUNCF) {
5795 | ins_next1
5796 }
5797 |2:
5798 | cmplw NARGS8:RC, TMP1 // Check for missing parameters.
5799 | blt >3
5800 if (op == BC_JFUNCF) {
5801 | decode_RD8 RD, INS
5802 | b =>BC_JLOOP
5803 } else {
5804 | ins_next2
5805 }
5806 |
5807 |3: // Clear missing parameters.
5808 | stwx TISNIL, BASE, NARGS8:RC
5809 | addi NARGS8:RC, NARGS8:RC, 8
5810 | b <2
5811 break;
5812
5813 case BC_JFUNCV:
5814 #if !LJ_HASJIT
5815 break;
5816 #endif
5817 | NYI // NYI: compiled vararg functions
5818 break; /* NYI: compiled vararg functions. */
5819
5820 case BC_IFUNCV:
5821 | // BASE = new base, RA = BASE+framesize*8, RB = LFUNC, RC = nargs*8
5822 | lwz TMP2, L->maxstack
5823 | add TMP1, BASE, RC
5824 | add TMP0, RA, RC
5825 | stw LFUNC:RB, 4(TMP1) // Store copy of LFUNC.
5826 | addi TMP3, RC, 8+FRAME_VARG
5827 | lwz KBASE, -4+PC2PROTO(k)(PC)
5828 | cmplw TMP0, TMP2
5829 | stw TMP3, 0(TMP1) // Store delta + FRAME_VARG.
5830 | bge ->vm_growstack_l
5831 | lbz TMP2, -4+PC2PROTO(numparams)(PC)
5832 | mr RA, BASE
5833 | mr RC, TMP1
5834 | ins_next1
5835 | cmpwi TMP2, 0
5836 | addi BASE, TMP1, 8
5837 | beq >3
5838 |1:
5839 | cmplw RA, RC // Less args than parameters?
5840 | lwz TMP0, 0(RA)
5841 | lwz TMP3, 4(RA)
5842 | bge >4
5843 | stw TISNIL, 0(RA) // Clear old fixarg slot (help the GC).
5844 | addi RA, RA, 8
5845 |2:
5846 | addic. TMP2, TMP2, -1
5847 | stw TMP0, 8(TMP1)
5848 | stw TMP3, 12(TMP1)
5849 | addi TMP1, TMP1, 8
5850 | bne <1
5851 |3:
5852 | ins_next2
5853 |
5854 |4: // Clear missing parameters.
5855 | li TMP0, LJ_TNIL
5856 | b <2
5857 break;
5858
5859 case BC_FUNCC:
5860 case BC_FUNCCW:
5861 | // BASE = new base, RA = BASE+framesize*8, RB = CFUNC, RC = nargs*8
5862 if (op == BC_FUNCC) {
5863 | lp RD, CFUNC:RB->f
5864 } else {
5865 | lp RD, DISPATCH_GL(wrapf)(DISPATCH)
5866 }
5867 | add TMP1, RA, NARGS8:RC
5868 | lwz TMP2, L->maxstack
5869 | .toc lp TMP3, 0(RD)
5870 | add RC, BASE, NARGS8:RC
5871 | stp BASE, L->base
5872 | cmplw TMP1, TMP2
5873 | stp RC, L->top
5874 | li_vmstate C
5875 |.if TOC
5876 | mtctr TMP3
5877 |.else
5878 | mtctr RD
5879 |.endif
5880 if (op == BC_FUNCCW) {
5881 | lp CARG2, CFUNC:RB->f
5882 }
5883 | mr CARG1, L
5884 | bgt ->vm_growstack_c // Need to grow stack.
5885 | .toc lp TOCREG, TOC_OFS(RD)
5886 | .tocenv lp ENVREG, ENV_OFS(RD)
5887 | st_vmstate
5888 | bctrl // (lua_State *L [, lua_CFunction f])
5889 | // Returns nresults.
5890 | lp BASE, L->base
5891 | .toc ld TOCREG, SAVE_TOC
5892 | slwi RD, CRET1, 3
5893 | lp TMP1, L->top
5894 | li_vmstate INTERP
5895 | lwz PC, FRAME_PC(BASE) // Fetch PC of caller.
5896 | stw L, DISPATCH_GL(cur_L)(DISPATCH)
5897 | sub RA, TMP1, RD // RA = L->top - nresults*8
5898 | st_vmstate
5899 | b ->vm_returnc
5900 break;
5901
5902 /* ---------------------------------------------------------------------- */
5903
5904 default:
5905 fprintf(stderr, "Error: undefined opcode BC_%s\n", bc_names[op]);
5906 exit(2);
5907 break;
5908 }
5909 }
5910
5911 static int build_backend(BuildCtx *ctx)
5912 {
5913 int op;
5914
5915 dasm_growpc(Dst, BC__MAX);
5916
5917 build_subroutines(ctx);
5918
5919 |.code_op
5920 for (op = 0; op < BC__MAX; op++)
5921 build_ins(ctx, (BCOp)op, op);
5922
5923 return BC__MAX;
5924 }
5925
5926 /* Emit pseudo frame-info for all assembler functions. */
5927 static void emit_asm_debug(BuildCtx *ctx)
5928 {
5929 int fcofs = (int)((uint8_t *)ctx->glob[GLOB_vm_ffi_call] - ctx->code);
5930 int i;
5931 switch (ctx->mode) {
5932 case BUILD_elfasm:
5933 fprintf(ctx->fp, "\t.section .debug_frame,\"\",@progbits\n");
5934 fprintf(ctx->fp,
5935 ".Lframe0:\n"
5936 "\t.long .LECIE0-.LSCIE0\n"
5937 ".LSCIE0:\n"
5938 "\t.long 0xffffffff\n"
5939 "\t.byte 0x1\n"
5940 "\t.string \"\"\n"
5941 "\t.uleb128 0x1\n"
5942 "\t.sleb128 -4\n"
5943 "\t.byte 65\n"
5944 "\t.byte 0xc\n\t.uleb128 1\n\t.uleb128 0\n"
5945 "\t.align 2\n"
5946 ".LECIE0:\n\n");
5947 fprintf(ctx->fp,
5948 ".LSFDE0:\n"
5949 "\t.long .LEFDE0-.LASFDE0\n"
5950 ".LASFDE0:\n"
5951 "\t.long .Lframe0\n"
5952 "\t.long .Lbegin\n"
5953 "\t.long %d\n"
5954 "\t.byte 0xe\n\t.uleb128 %d\n"
5955 "\t.byte 0x11\n\t.uleb128 65\n\t.sleb128 -1\n"
5956 "\t.byte 0x5\n\t.uleb128 70\n\t.uleb128 55\n",
5957 fcofs, CFRAME_SIZE);
5958 for (i = 14; i <= 31; i++)
5959 fprintf(ctx->fp,
5960 "\t.byte %d\n\t.uleb128 %d\n"
5961 "\t.byte %d\n\t.uleb128 %d\n",
5962 0x80+i, 37+(31-i), 0x80+32+i, 2+2*(31-i));
5963 fprintf(ctx->fp,
5964 "\t.align 2\n"
5965 ".LEFDE0:\n\n");
5966 #if LJ_HASFFI
5967 fprintf(ctx->fp,
5968 ".LSFDE1:\n"
5969 "\t.long .LEFDE1-.LASFDE1\n"
5970 ".LASFDE1:\n"
5971 "\t.long .Lframe0\n"
5972 #if LJ_TARGET_PS3
5973 "\t.long .lj_vm_ffi_call\n"
5974 #else
5975 "\t.long lj_vm_ffi_call\n"
5976 #endif
5977 "\t.long %d\n"
5978 "\t.byte 0x11\n\t.uleb128 65\n\t.sleb128 -1\n"
5979 "\t.byte 0x8e\n\t.uleb128 2\n"
5980 "\t.byte 0xd\n\t.uleb128 0xe\n"
5981 "\t.align 2\n"
5982 ".LEFDE1:\n\n", (int)ctx->codesz - fcofs);
5983 #endif
5984 #if !LJ_NO_UNWIND
5985 fprintf(ctx->fp, "\t.section .eh_frame,\"a\",@progbits\n");
5986 fprintf(ctx->fp,
5987 ".Lframe1:\n"
5988 "\t.long .LECIE1-.LSCIE1\n"
5989 ".LSCIE1:\n"
5990 "\t.long 0\n"
5991 "\t.byte 0x1\n"
5992 "\t.string \"zPR\"\n"
5993 "\t.uleb128 0x1\n"
5994 "\t.sleb128 -4\n"
5995 "\t.byte 65\n"
5996 "\t.uleb128 6\n" /* augmentation length */
5997 "\t.byte 0x1b\n" /* pcrel|sdata4 */
5998 "\t.long lj_err_unwind_dwarf-.\n"
5999 "\t.byte 0x1b\n" /* pcrel|sdata4 */
6000 "\t.byte 0xc\n\t.uleb128 1\n\t.uleb128 0\n"
6001 "\t.align 2\n"
6002 ".LECIE1:\n\n");
6003 fprintf(ctx->fp,
6004 ".LSFDE2:\n"
6005 "\t.long .LEFDE2-.LASFDE2\n"
6006 ".LASFDE2:\n"
6007 "\t.long .LASFDE2-.Lframe1\n"
6008 "\t.long .Lbegin-.\n"
6009 "\t.long %d\n"
6010 "\t.uleb128 0\n" /* augmentation length */
6011 "\t.byte 0xe\n\t.uleb128 %d\n"
6012 "\t.byte 0x11\n\t.uleb128 65\n\t.sleb128 -1\n"
6013 "\t.byte 0x5\n\t.uleb128 70\n\t.uleb128 55\n",
6014 fcofs, CFRAME_SIZE);
6015 for (i = 14; i <= 31; i++)
6016 fprintf(ctx->fp,
6017 "\t.byte %d\n\t.uleb128 %d\n"
6018 "\t.byte %d\n\t.uleb128 %d\n",
6019 0x80+i, 37+(31-i), 0x80+32+i, 2+2*(31-i));
6020 fprintf(ctx->fp,
6021 "\t.align 2\n"
6022 ".LEFDE2:\n\n");
6023 #if LJ_HASFFI
6024 fprintf(ctx->fp,
6025 ".Lframe2:\n"
6026 "\t.long .LECIE2-.LSCIE2\n"
6027 ".LSCIE2:\n"
6028 "\t.long 0\n"
6029 "\t.byte 0x1\n"
6030 "\t.string \"zR\"\n"
6031 "\t.uleb128 0x1\n"
6032 "\t.sleb128 -4\n"
6033 "\t.byte 65\n"
6034 "\t.uleb128 1\n" /* augmentation length */
6035 "\t.byte 0x1b\n" /* pcrel|sdata4 */
6036 "\t.byte 0xc\n\t.uleb128 1\n\t.uleb128 0\n"
6037 "\t.align 2\n"
6038 ".LECIE2:\n\n");
6039 fprintf(ctx->fp,
6040 ".LSFDE3:\n"
6041 "\t.long .LEFDE3-.LASFDE3\n"
6042 ".LASFDE3:\n"
6043 "\t.long .LASFDE3-.Lframe2\n"
6044 "\t.long lj_vm_ffi_call-.\n"
6045 "\t.long %d\n"
6046 "\t.uleb128 0\n" /* augmentation length */
6047 "\t.byte 0x11\n\t.uleb128 65\n\t.sleb128 -1\n"
6048 "\t.byte 0x8e\n\t.uleb128 2\n"
6049 "\t.byte 0xd\n\t.uleb128 0xe\n"
6050 "\t.align 2\n"
6051 ".LEFDE3:\n\n", (int)ctx->codesz - fcofs);
6052 #endif
6053 #endif
6054 break;
6055 default:
6056 break;
6057 }
6058 }
6059