src/buildvm_ppc.dasc

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