lj_bc.h (8786B)
1 /* 2 ** Bytecode instruction format. 3 ** Copyright (C) 2005-2016 Mike Pall. See Copyright Notice in luajit.h 4 */ 5 6 #ifndef _LJ_BC_H 7 #define _LJ_BC_H 8 9 #include "lj_def.h" 10 #include "lj_arch.h" 11 12 /* Bytecode instruction format, 32 bit wide, fields of 8 or 16 bit: 13 ** 14 ** +----+----+----+----+ 15 ** | B | C | A | OP | Format ABC 16 ** +----+----+----+----+ 17 ** | D | A | OP | Format AD 18 ** +-------------------- 19 ** MSB LSB 20 ** 21 ** In-memory instructions are always stored in host byte order. 22 */ 23 24 /* Operand ranges and related constants. */ 25 #define BCMAX_A 0xff 26 #define BCMAX_B 0xff 27 #define BCMAX_C 0xff 28 #define BCMAX_D 0xffff 29 #define BCBIAS_J 0x8000 30 #define NO_REG BCMAX_A 31 #define NO_JMP (~(BCPos)0) 32 33 /* Macros to get instruction fields. */ 34 #define bc_op(i) ((BCOp)((i)&0xff)) 35 #define bc_a(i) ((BCReg)(((i)>>8)&0xff)) 36 #define bc_b(i) ((BCReg)((i)>>24)) 37 #define bc_c(i) ((BCReg)(((i)>>16)&0xff)) 38 #define bc_d(i) ((BCReg)((i)>>16)) 39 #define bc_j(i) ((ptrdiff_t)bc_d(i)-BCBIAS_J) 40 41 /* Macros to set instruction fields. */ 42 #define setbc_byte(p, x, ofs) \ 43 ((uint8_t *)(p))[LJ_ENDIAN_SELECT(ofs, 3-ofs)] = (uint8_t)(x) 44 #define setbc_op(p, x) setbc_byte(p, (x), 0) 45 #define setbc_a(p, x) setbc_byte(p, (x), 1) 46 #define setbc_b(p, x) setbc_byte(p, (x), 3) 47 #define setbc_c(p, x) setbc_byte(p, (x), 2) 48 #define setbc_d(p, x) \ 49 ((uint16_t *)(p))[LJ_ENDIAN_SELECT(1, 0)] = (uint16_t)(x) 50 #define setbc_j(p, x) setbc_d(p, (BCPos)((int32_t)(x)+BCBIAS_J)) 51 52 /* Macros to compose instructions. */ 53 #define BCINS_ABC(o, a, b, c) \ 54 (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(b)<<24)|((BCIns)(c)<<16)) 55 #define BCINS_AD(o, a, d) \ 56 (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(d)<<16)) 57 #define BCINS_AJ(o, a, j) BCINS_AD(o, a, (BCPos)((int32_t)(j)+BCBIAS_J)) 58 59 /* Bytecode instruction definition. Order matters, see below. 60 ** 61 ** (name, filler, Amode, Bmode, Cmode or Dmode, metamethod) 62 ** 63 ** The opcode name suffixes specify the type for RB/RC or RD: 64 ** V = variable slot 65 ** S = string const 66 ** N = number const 67 ** P = primitive type (~itype) 68 ** B = unsigned byte literal 69 ** M = multiple args/results 70 */ 71 #if LJ_53 72 #define BCDEF_BITWISE(_) \ 73 /* Bitwise ops. They don't (yet?) have the VN/NV/VV form. */ \ 74 _(IDIV, dst, var, var, idiv) \ 75 _(BAND, dst, var, var, band) \ 76 _(BOR, dst, var, var, bor) \ 77 _(BXOR, dst, var, var, bxor) \ 78 _(SHL, dst, var, var, shl) \ 79 _(SHR, dst, var, var, shr) \ 80 _(BNOT, dst, ___, var, bnot) 81 #else 82 #define BCDEF_BITWISE(_) 83 #endif 84 85 #define BCDEF(_) \ 86 /* Comparison ops. ORDER OPR. */ \ 87 _(ISLT, var, ___, var, lt) \ 88 _(ISGE, var, ___, var, lt) \ 89 _(ISLE, var, ___, var, le) \ 90 _(ISGT, var, ___, var, le) \ 91 \ 92 _(ISEQV, var, ___, var, eq) \ 93 _(ISNEV, var, ___, var, eq) \ 94 _(ISEQS, var, ___, str, eq) \ 95 _(ISNES, var, ___, str, eq) \ 96 _(ISEQN, var, ___, num, eq) \ 97 _(ISNEN, var, ___, num, eq) \ 98 _(ISEQP, var, ___, pri, eq) \ 99 _(ISNEP, var, ___, pri, eq) \ 100 \ 101 /* Unary test and copy ops. */ \ 102 _(ISTC, dst, ___, var, ___) \ 103 _(ISFC, dst, ___, var, ___) \ 104 _(IST, ___, ___, var, ___) \ 105 _(ISF, ___, ___, var, ___) \ 106 _(ISTYPE, var, ___, lit, ___) \ 107 _(ISNUM, var, ___, lit, ___) \ 108 \ 109 /* Unary ops. */ \ 110 _(MOV, dst, ___, var, ___) \ 111 _(NOT, dst, ___, var, ___) \ 112 _(UNM, dst, ___, var, unm) \ 113 _(LEN, dst, ___, var, len) \ 114 \ 115 BCDEF_BITWISE(_) \ 116 \ 117 /* Binary ops. ORDER OPR. VV last, POW must be next. */ \ 118 _(ADDVN, dst, var, num, add) \ 119 _(SUBVN, dst, var, num, sub) \ 120 _(MULVN, dst, var, num, mul) \ 121 _(DIVVN, dst, var, num, div) \ 122 _(MODVN, dst, var, num, mod) \ 123 \ 124 _(ADDNV, dst, var, num, add) \ 125 _(SUBNV, dst, var, num, sub) \ 126 _(MULNV, dst, var, num, mul) \ 127 _(DIVNV, dst, var, num, div) \ 128 _(MODNV, dst, var, num, mod) \ 129 \ 130 _(ADDVV, dst, var, var, add) \ 131 _(SUBVV, dst, var, var, sub) \ 132 _(MULVV, dst, var, var, mul) \ 133 _(DIVVV, dst, var, var, div) \ 134 _(MODVV, dst, var, var, mod) \ 135 \ 136 _(POW, dst, var, var, pow) \ 137 _(CAT, dst, rbase, rbase, concat) \ 138 \ 139 /* Constant ops. */ \ 140 _(KSTR, dst, ___, str, ___) \ 141 _(KCDATA, dst, ___, cdata, ___) \ 142 _(KSHORT, dst, ___, lits, ___) \ 143 _(KNUM, dst, ___, num, ___) \ 144 _(KPRI, dst, ___, pri, ___) \ 145 _(KNIL, base, ___, base, ___) \ 146 \ 147 /* Upvalue and function ops. */ \ 148 _(JMP, rbase, ___, jump, ___) \ 149 _(UGET, dst, ___, uv, ___) \ 150 _(USETS, uv, ___, str, ___) \ 151 _(USETN, uv, ___, num, ___) \ 152 _(USETP, uv, ___, pri, ___) \ 153 _(UCLO, rbase, ___, jump, ___) \ 154 _(FNEW, dst, ___, func, gc) \ 155 \ 156 /* Table ops. */ \ 157 _(TNEW, dst, ___, lit, gc) \ 158 _(TDUP, dst, ___, tab, gc) \ 159 _(GGET, dst, ___, str, index) \ 160 _(GSET, var, ___, str, newindex) \ 161 _(TGETV, dst, var, var, index) \ 162 _(TGETS, dst, var, str, index) \ 163 _(TGETB, dst, var, lit, index) \ 164 _(TGETR, dst, var, var, index) \ 165 _(TSETV, var, var, var, newindex) \ 166 _(TSETS, var, var, str, newindex) \ 167 _(TSETB, var, var, lit, newindex) \ 168 _(TSETM, base, ___, num, newindex) \ 169 _(TSETR, var, var, var, newindex) \ 170 \ 171 /* Calls and vararg handling. T = tail call. */ \ 172 _(CALLM, base, lit, lit, call) \ 173 _(CALL, base, lit, lit, call) \ 174 _(CALLMT, base, ___, lit, call) \ 175 _(CALLT, base, ___, lit, call) \ 176 _(ITERC, base, lit, lit, call) \ 177 _(ITERN, base, lit, lit, call) \ 178 _(VARG, base, lit, lit, ___) \ 179 _(ISNEXT, base, ___, jump, ___) \ 180 \ 181 /* Returns. */ \ 182 _(RETM, base, ___, lit, ___) \ 183 _(RET, rbase, ___, lit, ___) \ 184 _(RET0, rbase, ___, lit, ___) \ 185 _(RET1, rbase, ___, lit, ___) \ 186 \ 187 /* Loops and branches. I/J = interp/JIT, I/C/L = init/call/loop. */ \ 188 _(FORI, base, ___, jump, ___) \ 189 _(JFORI, base, ___, jump, ___) \ 190 \ 191 _(FORL, base, ___, jump, ___) \ 192 _(IFORL, base, ___, jump, ___) \ 193 _(JFORL, base, ___, lit, ___) \ 194 \ 195 _(ITERL, base, ___, jump, ___) \ 196 _(IITERL, base, ___, jump, ___) \ 197 _(JITERL, base, ___, lit, ___) \ 198 \ 199 _(LOOP, rbase, ___, jump, ___) \ 200 _(ILOOP, rbase, ___, jump, ___) \ 201 _(JLOOP, rbase, ___, lit, ___) \ 202 \ 203 _(ESETV, uv, ___, var, ___) \ 204 _(USETV, uv, ___, var, ___) \ 205 \ 206 /* Function headers. I/J = interp/JIT, F/V/C = fixarg/vararg/C func. */ \ 207 _(FUNCF, rbase, ___, ___, ___) \ 208 _(IFUNCF, rbase, ___, ___, ___) \ 209 _(JFUNCF, rbase, ___, lit, ___) \ 210 _(FUNCV, rbase, ___, ___, ___) \ 211 _(IFUNCV, rbase, ___, ___, ___) \ 212 _(JFUNCV, rbase, ___, lit, ___) \ 213 _(FUNCC, rbase, ___, ___, ___) \ 214 _(FUNCCW, rbase, ___, ___, ___) \ 215 216 /* Bytecode opcode numbers. */ 217 typedef enum { 218 #define BCENUM(name, ma, mb, mc, mt) BC_##name, 219 BCDEF(BCENUM) 220 #undef BCENUM 221 BC__MAX 222 } BCOp; 223 224 LJ_STATIC_ASSERT((int)BC_ISEQV+1 == (int)BC_ISNEV); 225 LJ_STATIC_ASSERT(((int)BC_ISEQV^1) == (int)BC_ISNEV); 226 LJ_STATIC_ASSERT(((int)BC_ISEQS^1) == (int)BC_ISNES); 227 LJ_STATIC_ASSERT(((int)BC_ISEQN^1) == (int)BC_ISNEN); 228 LJ_STATIC_ASSERT(((int)BC_ISEQP^1) == (int)BC_ISNEP); 229 LJ_STATIC_ASSERT(((int)BC_ISLT^1) == (int)BC_ISGE); 230 LJ_STATIC_ASSERT(((int)BC_ISLE^1) == (int)BC_ISGT); 231 LJ_STATIC_ASSERT(((int)BC_ISLT^3) == (int)BC_ISGT); 232 LJ_STATIC_ASSERT((int)BC_IST-(int)BC_ISTC == (int)BC_ISF-(int)BC_ISFC); 233 LJ_STATIC_ASSERT((int)BC_CALLT-(int)BC_CALL == (int)BC_CALLMT-(int)BC_CALLM); 234 LJ_STATIC_ASSERT((int)BC_CALLMT + 1 == (int)BC_CALLT); 235 LJ_STATIC_ASSERT((int)BC_RETM + 1 == (int)BC_RET); 236 LJ_STATIC_ASSERT((int)BC_FORL + 1 == (int)BC_IFORL); 237 LJ_STATIC_ASSERT((int)BC_FORL + 2 == (int)BC_JFORL); 238 LJ_STATIC_ASSERT((int)BC_ITERL + 1 == (int)BC_IITERL); 239 LJ_STATIC_ASSERT((int)BC_ITERL + 2 == (int)BC_JITERL); 240 LJ_STATIC_ASSERT((int)BC_LOOP + 1 == (int)BC_ILOOP); 241 LJ_STATIC_ASSERT((int)BC_LOOP + 2 == (int)BC_JLOOP); 242 LJ_STATIC_ASSERT((int)BC_FUNCF + 1 == (int)BC_IFUNCF); 243 LJ_STATIC_ASSERT((int)BC_FUNCF + 2 == (int)BC_JFUNCF); 244 LJ_STATIC_ASSERT((int)BC_FUNCV + 1 == (int)BC_IFUNCV); 245 LJ_STATIC_ASSERT((int)BC_FUNCV + 2 == (int)BC_JFUNCV); 246 247 /* This solves a circular dependency problem, change as needed. */ 248 #define FF_next_N 4 249 250 /* Stack slots used by FORI/FORL, relative to operand A. */ 251 enum { 252 FORL_IDX, FORL_STOP, FORL_STEP, FORL_EXT 253 }; 254 255 /* Bytecode operand modes. ORDER BCMode */ 256 typedef enum { 257 BCMnone, BCMdst, BCMbase, BCMvar, BCMrbase, BCMuv, /* Mode A must be <= 7 */ 258 BCMlit, BCMlits, BCMpri, BCMnum, BCMstr, BCMtab, BCMfunc, BCMjump, BCMcdata, 259 BCM_max 260 } BCMode; 261 #define BCM___ BCMnone 262 263 #define bcmode_a(op) ((BCMode)(lj_bc_mode[op] & 7)) 264 #define bcmode_b(op) ((BCMode)((lj_bc_mode[op]>>3) & 15)) 265 #define bcmode_c(op) ((BCMode)((lj_bc_mode[op]>>7) & 15)) 266 #define bcmode_d(op) bcmode_c(op) 267 #define bcmode_hasd(op) ((lj_bc_mode[op] & (15<<3)) == (BCMnone<<3)) 268 #define bcmode_mm(op) ((MMS)(lj_bc_mode[op]>>11)) 269 270 #define BCMODE(name, ma, mb, mc, mm) \ 271 (BCM##ma|(BCM##mb<<3)|(BCM##mc<<7)|(MM_##mm<<11)), 272 #define BCMODE_FF 0 273 274 static LJ_AINLINE int bc_isret(BCOp op) 275 { 276 return (op == BC_RETM || op == BC_RET || op == BC_RET0 || op == BC_RET1); 277 } 278 279 LJ_DATA const uint16_t lj_bc_mode[]; 280 LJ_DATA const uint16_t lj_bc_ofs[]; 281 282 #endif