src/vm_ppc.dasc

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