src/vm_ppc.dasc

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