src/lj_bc.h

   1 /*
   2 ** Bytecode instruction format.
   3 ** Copyright (C) 2005-2010 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)        (cast(BCOp, (i)&0xff))
  35 #define bc_a(i)         (cast(BCReg, ((i)>>8)&0xff))
  36 #define bc_b(i)         (cast(BCReg, (i)>>24))
  37 #define bc_c(i)         (cast(BCReg, ((i)>>16)&0xff))
  38 #define bc_d(i)         (cast(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)] = cast_byte(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)] = cast(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   (cast(BCIns, o)|(cast(BCIns, a)<<8)|\
  55   (cast(BCIns, b)<<24)|(cast(BCIns, c)<<16))
  56 #define BCINS_AD(o, a, d) \
  57   (cast(BCIns, o)|(cast(BCIns, a)<<8)|(cast(BCIns, d)<<16))
  58 #define BCINS_AJ(o, a, j)       BCINS_AD(o, a, (BCPos)((int32_t)(j)+BCBIAS_J))
  59
  60 /* Bytecode instruction definition. Order matters, see below.
  61 **
  62 ** (name, filler, Amode, Bmode, Cmode or Dmode, metamethod)
  63 **
  64 ** The opcode name suffixes specify the type for RB/RC or RD:
  65 ** V = variable slot
  66 ** S = string const
  67 ** N = number const
  68 ** P = primitive type (~itype)
  69 ** B = unsigned byte literal
  70 ** M = multiple args/results
  71 */
  72 #define BCDEF(_) \
  73   /* Comparison ops. ORDER OPR. */ \
  74   _(ISLT,       var,    ___,    var,    lt) \
  75   _(ISGE,       var,    ___,    var,    lt) \
  76   _(ISLE,       var,    ___,    var,    le) \
  77   _(ISGT,       var,    ___,    var,    le) \
  78   \
  79   _(ISEQV,      var,    ___,    var,    eq) \
  80   _(ISNEV,      var,    ___,    var,    eq) \
  81   _(ISEQS,      var,    ___,    str,    eq) \
  82   _(ISNES,      var,    ___,    str,    eq) \
  83   _(ISEQN,      var,    ___,    num,    eq) \
  84   _(ISNEN,      var,    ___,    num,    eq) \
  85   _(ISEQP,      var,    ___,    pri,    eq) \
  86   _(ISNEP,      var,    ___,    pri,    eq) \
  87   \
  88   /* Unary test and copy ops. */ \
  89   _(ISTC,       dst,    ___,    var,    ___) \
  90   _(ISFC,       dst,    ___,    var,    ___) \
  91   _(IST,        ___,    ___,    var,    ___) \
  92   _(ISF,        ___,    ___,    var,    ___) \
  93   \
  94   /* Unary ops. */ \
  95   _(MOV,        dst,    ___,    var,    ___) \
  96   _(NOT,        dst,    ___,    var,    ___) \
  97   _(UNM,        dst,    ___,    var,    unm) \
  98   _(LEN,        dst,    ___,    var,    len) \
  99   \
 100   /* Binary ops. ORDER OPR. VV last, POW must be next. */ \
 101   _(ADDVN,      dst,    var,    num,    add) \
 102   _(SUBVN,      dst,    var,    num,    sub) \
 103   _(MULVN,      dst,    var,    num,    mul) \
 104   _(DIVVN,      dst,    var,    num,    div) \
 105   _(MODVN,      dst,    var,    num,    mod) \
 106   \
 107   _(ADDNV,      dst,    var,    num,    add) \
 108   _(SUBNV,      dst,    var,    num,    sub) \
 109   _(MULNV,      dst,    var,    num,    mul) \
 110   _(DIVNV,      dst,    var,    num,    div) \
 111   _(MODNV,      dst,    var,    num,    mod) \
 112   \
 113   _(ADDVV,      dst,    var,    var,    add) \
 114   _(SUBVV,      dst,    var,    var,    sub) \
 115   _(MULVV,      dst,    var,    var,    mul) \
 116   _(DIVVV,      dst,    var,    var,    div) \
 117   _(MODVV,      dst,    var,    var,    mod) \
 118   \
 119   _(POW,        dst,    var,    var,    pow) \
 120   _(CAT,        dst,    rbase,  rbase,  concat) \
 121   \
 122   /* Constant ops. */ \
 123   _(KSTR,       dst,    ___,    str,    ___) \
 124   _(KSHORT,     dst,    ___,    lits,   ___) \
 125   _(KNUM,       dst,    ___,    num,    ___) \
 126   _(KPRI,       dst,    ___,    pri,    ___) \
 127   _(KNIL,       base,   ___,    base,   ___) \
 128   \
 129   /* Upvalue and function ops. */ \
 130   _(UGET,       dst,    ___,    uv,     ___) \
 131   _(USETV,      uv,     ___,    var,    ___) \
 132   _(USETS,      uv,     ___,    str,    ___) \
 133   _(USETN,      uv,     ___,    num,    ___) \
 134   _(USETP,      uv,     ___,    pri,    ___) \
 135   _(UCLO,       rbase,  ___,    jump,   ___) \
 136   _(FNEW,       dst,    ___,    func,   gc) \
 137   \
 138   /* Table ops. */ \
 139   _(TNEW,       dst,    ___,    lit,    gc) \
 140   _(TDUP,       dst,    ___,    tab,    gc) \
 141   _(GGET,       dst,    ___,    str,    index) \
 142   _(GSET,       var,    ___,    str,    newindex) \
 143   _(TGETV,      dst,    var,    var,    index) \
 144   _(TGETS,      dst,    var,    str,    index) \
 145   _(TGETB,      dst,    var,    lit,    index) \
 146   _(TSETV,      var,    var,    var,    newindex) \
 147   _(TSETS,      var,    var,    str,    newindex) \
 148   _(TSETB,      var,    var,    lit,    newindex) \
 149   _(TSETM,      base,   ___,    num,    newindex) \
 150   \
 151   /* Calls and vararg handling. T = tail call. */ \
 152   _(CALLM,      base,   lit,    lit,    call) \
 153   _(CALL,       base,   lit,    lit,    call) \
 154   _(CALLMT,     base,   ___,    lit,    call) \
 155   _(CALLT,      base,   ___,    lit,    call) \
 156   _(ITERC,      base,   lit,    lit,    call) \
 157   _(VARG,       base,   lit,    lit,    ___) \
 158   \
 159   /* Returns. */ \
 160   _(RETM,       base,   ___,    lit,    ___) \
 161   _(RET,        rbase,  ___,    lit,    ___) \
 162   _(RET0,       rbase,  ___,    lit,    ___) \
 163   _(RET1,       rbase,  ___,    lit,    ___) \
 164   \
 165   /* Loops and branches. I/J = interp/JIT, I/C/L = init/call/loop. */ \
 166   _(FORI,       base,   ___,    jump,   ___) \
 167   _(JFORI,      base,   ___,    jump,   ___) \
 168   \
 169   _(FORL,       base,   ___,    jump,   ___) \
 170   _(IFORL,      base,   ___,    jump,   ___) \
 171   _(JFORL,      base,   ___,    lit,    ___) \
 172   \
 173   _(ITERL,      base,   ___,    jump,   ___) \
 174   _(IITERL,     base,   ___,    jump,   ___) \
 175   _(JITERL,     base,   ___,    lit,    ___) \
 176   \
 177   _(LOOP,       rbase,  ___,    jump,   ___) \
 178   _(ILOOP,      rbase,  ___,    jump,   ___) \
 179   _(JLOOP,      rbase,  ___,    lit,    ___) \
 180   \
 181   _(JMP,        rbase,  ___,    jump,   ___)
 182
 183 /* Bytecode opcode numbers. */
 184 typedef enum {
 185 #define BCENUM(name, ma, mb, mc, mt)    BC_##name,
 186 BCDEF(BCENUM)
 187 #undef BCENUM
 188   BC__MAX
 189 } BCOp;
 190
 191 LJ_STATIC_ASSERT((int)BC_ISEQV+1 == (int)BC_ISNEV);
 192 LJ_STATIC_ASSERT(((int)BC_ISEQV^1) == (int)BC_ISNEV);
 193 LJ_STATIC_ASSERT(((int)BC_ISEQS^1) == (int)BC_ISNES);
 194 LJ_STATIC_ASSERT(((int)BC_ISEQN^1) == (int)BC_ISNEN);
 195 LJ_STATIC_ASSERT(((int)BC_ISEQP^1) == (int)BC_ISNEP);
 196 LJ_STATIC_ASSERT(((int)BC_ISLT^1) == (int)BC_ISGE);
 197 LJ_STATIC_ASSERT(((int)BC_ISLE^1) == (int)BC_ISGT);
 198 LJ_STATIC_ASSERT(((int)BC_ISLT^3) == (int)BC_ISGT);
 199 LJ_STATIC_ASSERT((int)BC_IST-(int)BC_ISTC == (int)BC_ISF-(int)BC_ISFC);
 200 LJ_STATIC_ASSERT((int)BC_CALLT-(int)BC_CALL == (int)BC_CALLMT-(int)BC_CALLM);
 201 LJ_STATIC_ASSERT((int)BC_CALLMT + 1 == (int)BC_CALLT);
 202 LJ_STATIC_ASSERT((int)BC_RETM + 1 == (int)BC_RET);
 203 LJ_STATIC_ASSERT((int)BC_FORL + 1 == (int)BC_IFORL);
 204 LJ_STATIC_ASSERT((int)BC_FORL + 2 == (int)BC_JFORL);
 205 LJ_STATIC_ASSERT((int)BC_ITERL + 1 == (int)BC_IITERL);
 206 LJ_STATIC_ASSERT((int)BC_ITERL + 2 == (int)BC_JITERL);
 207 LJ_STATIC_ASSERT((int)BC_LOOP + 1 == (int)BC_ILOOP);
 208 LJ_STATIC_ASSERT((int)BC_LOOP + 2 == (int)BC_JLOOP);
 209
 210 /* Stack slots used by FORI/FORL, relative to operand A. */
 211 enum {
 212   FORL_IDX, FORL_STOP, FORL_STEP, FORL_EXT
 213 };
 214
 215 /* Bytecode operand modes. ORDER BCMode */
 216 typedef enum {
 217   BCMnone, BCMdst, BCMbase, BCMvar, BCMrbase, BCMuv,  /* Mode A must be <= 7 */
 218   BCMlit, BCMlits, BCMpri, BCMnum, BCMstr, BCMtab, BCMfunc, BCMjump,
 219   BCM_max
 220 } BCMode;
 221 #define BCM___          BCMnone
 222
 223 #define bcmode_a(op)    (cast(BCMode, lj_bc_mode[op] & 7))
 224 #define bcmode_b(op)    (cast(BCMode, (lj_bc_mode[op]>>3) & 15))
 225 #define bcmode_c(op)    (cast(BCMode, (lj_bc_mode[op]>>7) & 15))
 226 #define bcmode_d(op)    bcmode_c(op)
 227 #define bcmode_hasd(op) ((lj_bc_mode[op] & (15<<3)) == (BCMnone<<3))
 228 #define bcmode_mm(op)   (cast(MMS, lj_bc_mode[op]>>11))
 229
 230 #define BCMODE(name, ma, mb, mc, mm) \
 231   (BCM##ma|(BCM##mb<<3)|(BCM##mc<<7)|(MM_##mm<<11)),
 232
 233 LJ_DATA const uint16_t lj_bc_mode[BC__MAX+1];
 234
 235 #endif