src/buildvm_ppc.dasc

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