src/lj_bc.h - luajit-2.0-src

Global variables defined

lj_bc_mode
lj_bc_ofs
Data types defined

BCMode
BCOp
Functions defined

bc_isret
Macros defined

BCBIAS_J
BCDEF
BCENUM
BCENUM
BCINS_ABC
BCINS_AD
BCINS_AJ
BCMAX_A
BCMAX_B
BCMAX_C
BCMAX_D
BCMODE
BCMODE_FF
BCM___
FF_next_N
NO_JMP
NO_REG
_LJ_BC_H
bc_a
bc_b
bc_c
bc_d
bc_j
bc_op
bcmode_a
bcmode_b
bcmode_c
bcmode_d
bcmode_hasd
bcmode_mm
setbc_a
setbc_b
setbc_byte
setbc_c
setbc_d
setbc_j
setbc_op
Source code

/*

** Bytecode instruction format.

** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h

*/



#ifndef _LJ_BC_H

‌#define _LJ_BC_H



#include "lj_def.h"

#include "lj_arch.h"



/* Bytecode instruction format, 32 bit wide, fields of 8 or 16 bit:

**

** +----+----+----+----+

** | B  | C  | A  | OP | Format ABC

** +----+----+----+----+

** |    D    | A  | OP | Format AD

** +--------------------

** MSB               LSB

**

** In-memory instructions are always stored in host byte order.

*/



/* Operand ranges and related constants. */

‌#define BCMAX_A                0xff

‌#define BCMAX_B                0xff

‌#define BCMAX_C                0xff

‌#define BCMAX_D                0xffff

‌#define BCBIAS_J        0x8000

‌#define NO_REG                BCMAX_A

‌#define NO_JMP                (~(BCPos)0)



/* Macros to get instruction fields. */

‌#define bc_op(i)        ((BCOp)((i)&0xff))

‌#define bc_a(i)                ((BCReg)(((i)>>8)&0xff))

‌#define bc_b(i)                ((BCReg)((i)>>24))

‌#define bc_c(i)                ((BCReg)(((i)>>16)&0xff))

‌#define bc_d(i)                ((BCReg)((i)>>16))

‌#define bc_j(i)                ((ptrdiff_t)bc_d(i)-BCBIAS_J)



/* Macros to set instruction fields. */

‌#define setbc_byte(p, x, ofs) \

  ((uint8_t *)(p))[LJ_ENDIAN_SELECT(ofs, 3-ofs)] = (uint8_t)(x)

‌#define setbc_op(p, x)        setbc_byte(p, (x), 0)

‌#define setbc_a(p, x)        setbc_byte(p, (x), 1)

‌#define setbc_b(p, x)        setbc_byte(p, (x), 3)

‌#define setbc_c(p, x)        setbc_byte(p, (x), 2)

‌#define setbc_d(p, x) \

  ((uint16_t *)(p))[LJ_ENDIAN_SELECT(1, 0)] = (uint16_t)(x)

‌#define setbc_j(p, x)        setbc_d(p, (BCPos)((int32_t)(x)+BCBIAS_J))



/* Macros to compose instructions. */

‌#define BCINS_ABC(o, a, b, c) \

  (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(b)<<24)|((BCIns)(c)<<16))

‌#define BCINS_AD(o, a, d) \

  (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(d)<<16))

‌#define BCINS_AJ(o, a, j)        BCINS_AD(o, a, (BCPos)((int32_t)(j)+BCBIAS_J))



/* Bytecode instruction definition. Order matters, see below.

**

** (name, filler, Amode, Bmode, Cmode or Dmode, metamethod)

**

** The opcode name suffixes specify the type for RB/RC or RD:

** V = variable slot

** S = string const

** N = number const

** P = primitive type (~itype)

** B = unsigned byte literal

** M = multiple args/results

*/

‌#define BCDEF(_) \

  /* Comparison ops. ORDER OPR. */ \

  _(ISLT,        var,        ___,        var,        lt) \

  _(ISGE,        var,        ___,        var,        lt) \

  _(ISLE,        var,        ___,        var,        le) \

  _(ISGT,        var,        ___,        var,        le) \

  \

  _(ISEQV,        var,        ___,        var,        eq) \

  _(ISNEV,        var,        ___,        var,        eq) \

  _(ISEQS,        var,        ___,        str,        eq) \

  _(ISNES,        var,        ___,        str,        eq) \

  _(ISEQN,        var,        ___,        num,        eq) \

  _(ISNEN,        var,        ___,        num,        eq) \

  _(ISEQP,        var,        ___,        pri,        eq) \

  _(ISNEP,        var,        ___,        pri,        eq) \

  \

  /* Unary test and copy ops. */ \

  _(ISTC,        dst,        ___,        var,        ___) \

  _(ISFC,        dst,        ___,        var,        ___) \

  _(IST,        ___,        ___,        var,        ___) \

  _(ISF,        ___,        ___,        var,        ___) \

  _(ISTYPE,        var,        ___,        lit,        ___) \

  _(ISNUM,        var,        ___,        lit,        ___) \

  \

  /* Unary ops. */ \

  _(MOV,        dst,        ___,        var,        ___) \

  _(NOT,        dst,        ___,        var,        ___) \

  _(UNM,        dst,        ___,        var,        unm) \

  _(LEN,        dst,        ___,        var,        len) \

  \

  /* Binary ops. ORDER OPR. VV last, POW must be next. */ \

  _(ADDVN,        dst,        var,        num,        add) \

  _(SUBVN,        dst,        var,        num,        sub) \

  _(MULVN,        dst,        var,        num,        mul) \

  _(DIVVN,        dst,        var,        num,        div) \

  _(MODVN,        dst,        var,        num,        mod) \

  \

  _(ADDNV,        dst,        var,        num,        add) \

  _(SUBNV,        dst,        var,        num,        sub) \

  _(MULNV,        dst,        var,        num,        mul) \

  _(DIVNV,        dst,        var,        num,        div) \

  _(MODNV,        dst,        var,        num,        mod) \

  \

  _(ADDVV,        dst,        var,        var,        add) \

  _(SUBVV,        dst,        var,        var,        sub) \

  _(MULVV,        dst,        var,        var,        mul) \

  _(DIVVV,        dst,        var,        var,        div) \

  _(MODVV,        dst,        var,        var,        mod) \

  \

  _(POW,        dst,        var,        var,        pow) \

  _(CAT,        dst,        rbase,        rbase,        concat) \

  \

  /* Constant ops. */ \

  _(KSTR,        dst,        ___,        str,        ___) \

  _(KCDATA,        dst,        ___,        cdata,        ___) \

  _(KSHORT,        dst,        ___,        lits,        ___) \

  _(KNUM,        dst,        ___,        num,        ___) \

  _(KPRI,        dst,        ___,        pri,        ___) \

  _(KNIL,        base,        ___,        base,        ___) \

  \

  /* Upvalue and function ops. */ \

  _(UGET,        dst,        ___,        uv,        ___) \

  _(USETV,        uv,        ___,        var,        ___) \

  _(USETS,        uv,        ___,        str,        ___) \

  _(USETN,        uv,        ___,        num,        ___) \

  _(USETP,        uv,        ___,        pri,        ___) \

  _(UCLO,        rbase,        ___,        jump,        ___) \

  _(FNEW,        dst,        ___,        func,        gc) \

  \

  /* Table ops. */ \

  _(TNEW,        dst,        ___,        lit,        gc) \

  _(TDUP,        dst,        ___,        tab,        gc) \

  _(GGET,        dst,        ___,        str,        index) \

  _(GSET,        var,        ___,        str,        newindex) \

  _(TGETV,        dst,        var,        var,        index) \

  _(TGETS,        dst,        var,        str,        index) \

  _(TGETB,        dst,        var,        lit,        index) \

  _(TGETR,        dst,        var,        var,        index) \

  _(TSETV,        var,        var,        var,        newindex) \

  _(TSETS,        var,        var,        str,        newindex) \

  _(TSETB,        var,        var,        lit,        newindex) \

  _(TSETM,        base,        ___,        num,        newindex) \

  _(TSETR,        var,        var,        var,        newindex) \

  \

  /* Calls and vararg handling. T = tail call. */ \

  _(CALLM,        base,        lit,        lit,        call) \

  _(CALL,        base,        lit,        lit,        call) \

  _(CALLMT,        base,        ___,        lit,        call) \

  _(CALLT,        base,        ___,        lit,        call) \

  _(ITERC,        base,        lit,        lit,        call) \

  _(ITERN,        base,        lit,        lit,        call) \

  _(VARG,        base,        lit,        lit,        ___) \

  _(ISNEXT,        base,        ___,        jump,        ___) \

  \

  /* Returns. */ \

  _(RETM,        base,        ___,        lit,        ___) \

  _(RET,        rbase,        ___,        lit,        ___) \

  _(RET0,        rbase,        ___,        lit,        ___) \

  _(RET1,        rbase,        ___,        lit,        ___) \

  \

  /* Loops and branches. I/J = interp/JIT, I/C/L = init/call/loop. */ \

  _(FORI,        base,        ___,        jump,        ___) \

  _(JFORI,        base,        ___,        jump,        ___) \

  \

  _(FORL,        base,        ___,        jump,        ___) \

  _(IFORL,        base,        ___,        jump,        ___) \

  _(JFORL,        base,        ___,        lit,        ___) \

  \

  _(ITERL,        base,        ___,        jump,        ___) \

  _(IITERL,        base,        ___,        jump,        ___) \

  _(JITERL,        base,        ___,        lit,        ___) \

  \

  _(LOOP,        rbase,        ___,        jump,        ___) \

  _(ILOOP,        rbase,        ___,        jump,        ___) \

  _(JLOOP,        rbase,        ___,        lit,        ___) \

  \

  _(JMP,        rbase,        ___,        jump,        ___) \

  \

  /* Function headers. I/J = interp/JIT, F/V/C = fixarg/vararg/C func. */ \

  _(FUNCF,        rbase,        ___,        ___,        ___) \

  _(IFUNCF,        rbase,        ___,        ___,        ___) \

  _(JFUNCF,        rbase,        ___,        lit,        ___) \

  _(FUNCV,        rbase,        ___,        ___,        ___) \

  _(IFUNCV,        rbase,        ___,        ___,        ___) \

  _(JFUNCV,        rbase,        ___,        lit,        ___) \

  _(FUNCC,        rbase,        ___,        ___,        ___) \

  _(FUNCCW,        rbase,        ___,        ___,        ___)



/* Bytecode opcode numbers. */

typedef enum {

‌#define BCENUM(name, ma, mb, mc, mt)        BC_##name,

BCDEF(BCENUM)

‌#undef BCENUM

  BC__MAX

‌} BCOp;



LJ_STATIC_ASSERT((int)BC_ISEQV+1 == (int)BC_ISNEV);

LJ_STATIC_ASSERT(((int)BC_ISEQV^1) == (int)BC_ISNEV);

LJ_STATIC_ASSERT(((int)BC_ISEQS^1) == (int)BC_ISNES);

LJ_STATIC_ASSERT(((int)BC_ISEQN^1) == (int)BC_ISNEN);

LJ_STATIC_ASSERT(((int)BC_ISEQP^1) == (int)BC_ISNEP);

LJ_STATIC_ASSERT(((int)BC_ISLT^1) == (int)BC_ISGE);

LJ_STATIC_ASSERT(((int)BC_ISLE^1) == (int)BC_ISGT);

LJ_STATIC_ASSERT(((int)BC_ISLT^3) == (int)BC_ISGT);

LJ_STATIC_ASSERT((int)BC_IST-(int)BC_ISTC == (int)BC_ISF-(int)BC_ISFC);

LJ_STATIC_ASSERT((int)BC_CALLT-(int)BC_CALL == (int)BC_CALLMT-(int)BC_CALLM);

LJ_STATIC_ASSERT((int)BC_CALLMT + 1 == (int)BC_CALLT);

LJ_STATIC_ASSERT((int)BC_RETM + 1 == (int)BC_RET);

LJ_STATIC_ASSERT((int)BC_FORL + 1 == (int)BC_IFORL);

LJ_STATIC_ASSERT((int)BC_FORL + 2 == (int)BC_JFORL);

LJ_STATIC_ASSERT((int)BC_ITERL + 1 == (int)BC_IITERL);

LJ_STATIC_ASSERT((int)BC_ITERL + 2 == (int)BC_JITERL);

LJ_STATIC_ASSERT((int)BC_LOOP + 1 == (int)BC_ILOOP);

LJ_STATIC_ASSERT((int)BC_LOOP + 2 == (int)BC_JLOOP);

LJ_STATIC_ASSERT((int)BC_FUNCF + 1 == (int)BC_IFUNCF);

LJ_STATIC_ASSERT((int)BC_FUNCF + 2 == (int)BC_JFUNCF);

LJ_STATIC_ASSERT((int)BC_FUNCV + 1 == (int)BC_IFUNCV);

LJ_STATIC_ASSERT((int)BC_FUNCV + 2 == (int)BC_JFUNCV);



/* This solves a circular dependency problem, change as needed. */

‌#define FF_next_N        4



/* Stack slots used by FORI/FORL, relative to operand A. */

enum {

  FORL_IDX, FORL_STOP, FORL_STEP, FORL_EXT

};



/* Bytecode operand modes. ORDER BCMode */

typedef enum {

  BCMnone, BCMdst, BCMbase, BCMvar, BCMrbase, BCMuv,  /* Mode A must be <= 7 */

  BCMlit, BCMlits, BCMpri, BCMnum, BCMstr, BCMtab, BCMfunc, BCMjump, BCMcdata,

  BCM_max

‌} BCMode;

‌#define BCM___                BCMnone



‌#define bcmode_a(op)        ((BCMode)(lj_bc_mode[op] & 7))

‌#define bcmode_b(op)        ((BCMode)((lj_bc_mode[op]>>3) & 15))

‌#define bcmode_c(op)        ((BCMode)((lj_bc_mode[op]>>7) & 15))

‌#define bcmode_d(op)        bcmode_c(op)

‌#define bcmode_hasd(op)        ((lj_bc_mode[op] & (15<<3)) == (BCMnone<<3))

‌#define bcmode_mm(op)        ((MMS)(lj_bc_mode[op]>>11))



‌#define BCMODE(name, ma, mb, mc, mm) \

  (BCM##ma|(BCM##mb<<3)|(BCM##mc<<7)|(MM_##mm<<11)),

‌#define BCMODE_FF        0



‌static LJ_AINLINE int bc_isret(BCOp op)

{

  return (op == BC_RETM || op == BC_RET || op == BC_RET0 || op == BC_RET1);

}



‌LJ_DATA const uint16_t lj_bc_mode[];

‌LJ_DATA const uint16_t lj_bc_ofs[];



#endif