One Level Up Top Level

include/ktap_bc.h - ktap

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * Bytecode instruction format.
  3. *
  4. * Copyright (C) 2012-2014 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  5. * Copyright (C) 2005-2014 Mike Pall.
  6. */

  8. #ifndef __KTAP_BC_H__
  9. ‌#define __KTAP_BC_H__

  11. #include "../include/ktap_arch.h"

  13. /*TODO*/
  14. ‌#define KP_STATIC_ASSERT(cond)
  15. ‌#define kp_assert(cond)

  17. /* Types for handling bytecodes. */
  18. ‌typedef uint32_t BCIns;  /* Bytecode instruction. */
  19. ‌typedef uint32_t BCPos;  /* Bytecode position. */
  20. ‌typedef uint32_t BCReg;  /* Bytecode register. */
  21. ‌typedef int32_t BCLine;  /* Bytecode line number. */

  23. /*
  24. * Bytecode instruction format, 32 bit wide, fields of 8 or 16 bit:
  25. *
  26. * +----+----+----+----+
  27. * | B  | C  | A  | OP | Format ABC
  28. * +----+----+----+----+
  29. * |    D    | A  | OP | Format AD
  30. * +--------------------
  31. * MSB               LSB
  32. *
  33. * In-memory instructions are always stored in host byte order.
  34. */

  36. /* Operand ranges and related constants. */
  37. ‌#define BCMAX_A        0xff
  38. ‌#define BCMAX_B        0xff
  39. ‌#define BCMAX_C        0xff
  40. ‌#define BCMAX_D        0xffff
  41. ‌#define BCBIAS_J    0x8000
  42. ‌#define NO_REG        BCMAX_A
  43. ‌#define NO_JMP        (~(BCPos)0)

  45. /* Macros to get instruction fields. */
  46. ‌#define bc_op(i)    ((BCOp)((i)&0xff))
  47. ‌#define bc_a(i)        ((BCReg)(((i)>>8)&0xff))
  48. ‌#define bc_b(i)        ((BCReg)((i)>>24))
  49. ‌#define bc_c(i)        ((BCReg)(((i)>>16)&0xff))
  50. ‌#define bc_d(i)        ((BCReg)((i)>>16))
  51. ‌#define bc_j(i)        ((ptrdiff_t)bc_d(i)-BCBIAS_J)

  53. /* Macros to set instruction fields. */
  54. ‌#define setbc_byte(p, x, ofs) \
  55.     ((uint8_t *)(p))[KP_ENDIAN_SELECT(ofs, 3 - ofs)] = (uint8_t)(x)
  56. ‌#define setbc_op(p, x)    setbc_byte(p, (x), 0)
  57. ‌#define setbc_a(p, x)    setbc_byte(p, (x), 1)
  58. ‌#define setbc_b(p, x)    setbc_byte(p, (x), 3)
  59. ‌#define setbc_c(p, x)    setbc_byte(p, (x), 2)
  60. ‌#define setbc_d(p, x) \
  61.     ((uint16_t *)(p))[KP_ENDIAN_SELECT(1, 0)] = (uint16_t)(x)
  62. ‌#define setbc_j(p, x)    setbc_d(p, (BCPos)((int32_t)(x)+BCBIAS_J))

  64. /* Macros to compose instructions. */
  65. ‌#define BCINS_ABC(o, a, b, c) \
  66.     (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(b)<<24)|((BCIns)(c)<<16))
  67. ‌#define BCINS_AD(o, a, d) \
  68.     (((BCIns)(o))|((BCIns)(a)<<8)|((BCIns)(d)<<16))
  69. ‌#define BCINS_AJ(o, a, j)    BCINS_AD(o, a, (BCPos)((int32_t)(j)+BCBIAS_J))

  71. /*
  72. * Bytecode instruction definition. Order matters, see below.
  73. *
  74. * (name, filler, Amode, Bmode, Cmode or Dmode, metamethod)
  75. *
  76. * The opcode name suffixes specify the type for RB/RC or RD:
  77. * V = variable slot
  78. * S = string const
  79. * N = number const
  80. * P = primitive type (~itype)
  81. * B = unsigned byte literal
  82. * M = multiple args/results
  83. */
  84. ‌#define BCDEF(_) \
  85.     /* Comparison ops. ORDER OPR. */ \
  86.     _(ISLT,    var,    ___,    var,    lt) \
  87.     _(ISGE,    var,    ___,    var,    lt) \
  88.     _(ISLE,    var,    ___,    var,    le) \
  89.     _(ISGT,    var,    ___,    var,    le) \
  90.     \
  91.     _(ISEQV,    var,    ___,    var,    eq) \
  92.     _(ISNEV,    var,    ___,    var,    eq) \
  93.     _(ISEQS,    var,    ___,    str,    eq) \
  94.     _(ISNES,    var,    ___,    str,    eq) \
  95.     _(ISEQN,    var,    ___,    num,    eq) \
  96.     _(ISNEN,    var,    ___,    num,    eq) \
  97.     _(ISEQP,    var,    ___,    pri,    eq) \
  98.     _(ISNEP,    var,    ___,    pri,    eq) \
  99.     \
  100.     /* Unary test and copy ops. */ \
  101.     _(ISTC,    dst,    ___,    var,    ___) \
  102.     _(ISFC,    dst,    ___,    var,    ___) \
  103.     _(IST,    ___,    ___,    var,    ___) \
  104.     _(ISF,    ___,    ___,    var,    ___) \
  105.     _(ISTYPE,    var,    ___,    lit,    ___) \
  106.     _(ISNUM,    var,    ___,    lit,    ___) \
  107.     \
  108.     /* Unary ops. */ \
  109.     _(MOV,    dst,    ___,    var,    ___) \
  110.     _(NOT,    dst,    ___,    var,    ___) \
  111.     _(UNM,    dst,    ___,    var,    unm) \
  112.     \
  113.     /* Binary ops. ORDER OPR. VV last, POW must be next. */ \
  114.     _(ADDVN,    dst,    var,    num,    add) \
  115.     _(SUBVN,    dst,    var,    num,    sub) \
  116.     _(MULVN,    dst,    var,    num,    mul) \
  117.     _(DIVVN,    dst,    var,    num,    div) \
  118.     _(MODVN,    dst,    var,    num,    mod) \
  119.     \
  120.     _(ADDNV,    dst,    var,    num,    add) \
  121.     _(SUBNV,    dst,    var,    num,    sub) \
  122.     _(MULNV,    dst,    var,    num,    mul) \
  123.     _(DIVNV,    dst,    var,    num,    div) \
  124.     _(MODNV,    dst,    var,    num,    mod) \
  125.     \
  126.     _(ADDVV,    dst,    var,    var,    add) \
  127.     _(SUBVV,    dst,    var,    var,    sub) \
  128.     _(MULVV,    dst,    var,    var,    mul) \
  129.     _(DIVVV,    dst,    var,    var,    div) \
  130.     _(MODVV,    dst,    var,    var,    mod) \
  131.     \
  132.     _(POW,    dst,    var,    var,    pow) \
  133.     _(CAT,    dst,    rbase,    rbase,    concat) \
  134.     \
  135.     /* Constant ops. */ \
  136.     _(KSTR,    dst,    ___,    str,    ___) \
  137.     _(KCDATA,    dst,    ___,    cdata,    ___) \
  138.     _(KSHORT,    dst,    ___,    lits,    ___) \
  139.     _(KNUM,    dst,    ___,    num,    ___) \
  140.     _(KPRI,    dst,    ___,    pri,    ___) \
  141.     _(KNIL,    base,    ___,    base,    ___) \
  142.     \
  143.     /* Upvalue and function ops. */ \
  144.     _(UGET,    dst,    ___,    uv,    ___) \
  145.     _(USETV,    uv,    ___,    var,    ___) \
  146.     _(UINCV,    uv,    ___,    var,    ___) \
  147.     _(USETS,    uv,    ___,    str,    ___) \
  148.     _(USETN,    uv,    ___,    num,    ___) \
  149.     _(UINCN,    uv,    ___,    num,    ___) \
  150.     _(USETP,    uv,    ___,    pri,    ___) \
  151.     _(UCLO,    rbase,    ___,    jump,    ___) \
  152.     _(FNEW,    dst,    ___,    func,    gc) \
  153.     \
  154.     /* Table ops. */ \
  155.     _(TNEW,    dst,    ___,    lit,    gc) \
  156.     _(TDUP,    dst,    ___,    tab,    gc) \
  157.     _(GGET,    dst,    ___,    str,    index) \
  158.     _(GSET,    var,    ___,    str,    newindex) \
  159.     _(GINC,    var,    ___,    str,    newindex) \
  160.     _(TGETV,    dst,    var,    var,    index) \
  161.     _(TGETS,    dst,    var,    str,    index) \
  162.     _(TGETB,    dst,    var,    lit,    index) \
  163.     _(TGETR,    dst,    var,    var,    index) \
  164.     _(TSETV,    var,    var,    var,    newindex) \
  165.     _(TINCV,    var,    var,    var,    newindex) \
  166.     _(TSETS,    var,    var,    str,    newindex) \
  167.     _(TINCS,    var,    var,    str,    newindex) \
  168.     _(TSETB,    var,    var,    lit,    newindex) \
  169.     _(TINCB,    var,    var,    lit,    newindex) \
  170.     _(TSETM,    base,    ___,    num,    newindex) \
  171.     _(TSETR,    var,    var,    var,    newindex) \
  172.     \
  173.     /* Calls and vararg handling. T = tail call. */ \
  174.     _(CALLM,    base,    lit,    lit,    call) \
  175.     _(CALL,    base,    lit,    lit,    call) \
  176.     _(CALLMT,    base,    ___,    lit,    call) \
  177.     _(CALLT,    base,    ___,    lit,    call) \
  178.     _(ITERC,    base,    lit,    lit,    call) \
  179.     _(ITERN,    base,    lit,    lit,    call) \
  180.     _(VARG,    base,    lit,    lit,    ___) \
  181.     _(ISNEXT,    base,    ___,    jump,    ___) \
  182.     \
  183.     /* Returns. */ \
  184.     _(RETM,    base,    ___,    lit,    ___) \
  185.     _(RET,    rbase,    ___,    lit,    ___) \
  186.     _(RET0,    rbase,    ___,    lit,    ___) \
  187.     _(RET1,    rbase,    ___,    lit,    ___) \
  188.     \
  189.     /* Loops and branches. I/J = interp/JIT, I/C/L = init/call/loop. */ \
  190.     _(FORI,    base,    ___,    jump,    ___) \
  191.     _(JFORI,    base,    ___,    jump,    ___) \
  192.     \
  193.     _(FORL,    base,    ___,    jump,    ___) \
  194.     _(IFORL,    base,    ___,    jump,    ___) \
  195.     _(JFORL,    base,    ___,    lit,    ___) \
  196.     \
  197.     _(ITERL,    base,    ___,    jump,    ___) \
  198.     _(IITERL,    base,    ___,    jump,    ___) \
  199.     _(JITERL,    base,    ___,    lit,    ___) \
  200.     \
  201.     _(LOOP,    rbase,    ___,    jump,    ___) \
  202.     _(ILOOP,    rbase,    ___,    jump,    ___) \
  203.     _(JLOOP,    rbase,    ___,    lit,    ___) \
  204.     \
  205.     _(JMP,    rbase,    ___,    jump,    ___) \
  206.     \
  207.     /*Function headers. I/J = interp/JIT, F/V/C = fixarg/vararg/C func.*/ \
  208.     _(FUNCF,    rbase,    ___,    ___,    ___) \
  209.     _(IFUNCF,    rbase,    ___,    ___,    ___) \
  210.     _(JFUNCF,    rbase,    ___,    lit,    ___) \
  211.     _(FUNCV,    rbase,    ___,    ___,    ___) \
  212.     _(IFUNCV,    rbase,    ___,    ___,    ___) \
  213.     _(JFUNCV,    rbase,    ___,    lit,    ___) \
  214.     _(FUNCC,    rbase,    ___,    ___,    ___) \
  215.     _(FUNCCW,    rbase,    ___,    ___,    ___) \
  216.     \
  217.     /* specific purpose bc. */    \
  218.     _(VARGN,    dst, ___,    lit,    ___) \
  219.     _(VARGSTR,    dst, ___,    lit,    ___) \
  220.     _(VPROBENAME,    dst, ___,    lit,    ___) \
  221.     _(VPID,        dst, ___,    lit,    ___) \
  222.     _(VTID,        dst, ___,    lit,    ___) \
  223.     _(VUID,        dst, ___,    lit,    ___) \
  224.     _(VCPU,        dst, ___,    lit,    ___) \
  225.     _(VEXECNAME,    dst, ___,    lit,    ___) \
  226.     \
  227.     _(GFUNC,    dst, ___,    ___,    ___) /*load global C function*/

  229. /* Bytecode opcode numbers. */
  230. typedef enum {
  231. ‌#define BCENUM(name, ma, mb, mc, mt)    BC_##name,
  232.     BCDEF(BCENUM)
  233. ‌#undef BCENUM
  234.     BC__MAX
  235. ‌} BCOp;

  237. KP_STATIC_ASSERT((int)BC_ISEQV+1 == (int)BC_ISNEV);
  238. KP_STATIC_ASSERT(((int)BC_ISEQV^1) == (int)BC_ISNEV);
  239. KP_STATIC_ASSERT(((int)BC_ISEQS^1) == (int)BC_ISNES);
  240. KP_STATIC_ASSERT(((int)BC_ISEQN^1) == (int)BC_ISNEN);
  241. KP_STATIC_ASSERT(((int)BC_ISEQP^1) == (int)BC_ISNEP);
  242. KP_STATIC_ASSERT(((int)BC_ISLT^1) == (int)BC_ISGE);
  243. KP_STATIC_ASSERT(((int)BC_ISLE^1) == (int)BC_ISGT);
  244. KP_STATIC_ASSERT(((int)BC_ISLT^3) == (int)BC_ISGT);
  245. KP_STATIC_ASSERT((int)BC_IST-(int)BC_ISTC == (int)BC_ISF-(int)BC_ISFC);
  246. KP_STATIC_ASSERT((int)BC_CALLT-(int)BC_CALL == (int)BC_CALLMT-(int)BC_CALLM);
  247. KP_STATIC_ASSERT((int)BC_CALLMT + 1 == (int)BC_CALLT);
  248. KP_STATIC_ASSERT((int)BC_RETM + 1 == (int)BC_RET);
  249. KP_STATIC_ASSERT((int)BC_FORL + 1 == (int)BC_IFORL);
  250. KP_STATIC_ASSERT((int)BC_FORL + 2 == (int)BC_JFORL);
  251. KP_STATIC_ASSERT((int)BC_ITERL + 1 == (int)BC_IITERL);
  252. KP_STATIC_ASSERT((int)BC_ITERL + 2 == (int)BC_JITERL);
  253. KP_STATIC_ASSERT((int)BC_LOOP + 1 == (int)BC_ILOOP);
  254. KP_STATIC_ASSERT((int)BC_LOOP + 2 == (int)BC_JLOOP);
  255. KP_STATIC_ASSERT((int)BC_FUNCF + 1 == (int)BC_IFUNCF);
  256. KP_STATIC_ASSERT((int)BC_FUNCF + 2 == (int)BC_JFUNCF);
  257. KP_STATIC_ASSERT((int)BC_FUNCV + 1 == (int)BC_IFUNCV);
  258. KP_STATIC_ASSERT((int)BC_FUNCV + 2 == (int)BC_JFUNCV);

  260. /* This solves a circular dependency problem, change as needed. */
  261. ‌#define FF_next_N    4

  263. /* Stack slots used by FORI/FORL, relative to operand A. */
  264. enum {
  265.     FORL_IDX, FORL_STOP, FORL_STEP, FORL_EXT
  266. };

  268. /* Bytecode operand modes. ORDER BCMode */
  269. typedef enum {
  270.     /* Mode A must be <= 7 */
  271.     BCMnone, BCMdst, BCMbase, BCMvar, BCMrbase, BCMuv,
  272.     BCMlit, BCMlits, BCMpri, BCMnum, BCMstr, BCMtab, BCMfunc,
  273.     BCMjump, BCMcdata,
  274.     BCM_max
  275. ‌} BCMode;

  277. ‌#define BCM___    BCMnone

  279. ‌#define bcmode_a(op)    ((BCMode)(bc_mode[op] & 7))
  280. ‌#define bcmode_b(op)    ((BCMode)((bc_mode[op] >> 3) & 15))
  281. ‌#define bcmode_c(op)    ((BCMode)((bc_mode[op] >> 7) & 15))
  282. ‌#define bcmode_d(op)    bcmode_c(op)
  283. ‌#define bcmode_hasd(op)    ((bc_mode[op] & (15 << 3)) == (BCMnone << 3))
  284. ‌#define bcmode_mm(op)    ((MMS)(bc_mode[op] >> 11))

  286. ‌#define BCMODE(name, ma, mb, mc, mm) \
  287.     (BCM##ma | (BCM##mb << 3) | (BCM##mc << 7)|(MM_##mm << 11)),
  288. ‌#define BCMODE_FF    0

  290. ‌static inline int bc_isret(BCOp op)
  291. {
  292.     return (op == BC_RETM || op == BC_RET || op == BC_RET0 ||
  293.         op == BC_RET1);
  294. }

  296. /*
  297. * Metamethod definition
  298. * Note ktap don't use any lua methmethod currently.
  299. */
  300. typedef enum {
  301.     MM_lt,
  302.     MM_le,
  303.     MM_eq,
  304.     MM_unm,
  305.     MM_add,
  306.     MM_sub,
  307.     MM_mul,
  308.     MM_div,
  309.     MM_mod,
  310.     MM_pow,
  311.     MM_concat,
  312.     MM_gc,
  313.     MM_index,
  314.     MM_newindex,
  315.     MM_call,
  316.     MM__MAX,
  317.     MM____ = MM__MAX
  318. ‌} MMS;


  321. /* -- Bytecode dump format ------------------------------------------------ */

  323. /*
  324. ** dump   = header proto+ 0U
  325. ** header = ESC 'L' 'J' versionB flagsU [namelenU nameB*]
  326. ** proto  = lengthU pdata
  327. ** pdata  = phead bcinsW* uvdataH* kgc* knum* [debugB*]
  328. ** phead  = flagsB numparamsB framesizeB numuvB numkgcU numknU numbcU
  329. **          [debuglenU [firstlineU numlineU]]
  330. ** kgc    = kgctypeU { ktab | (loU hiU) | (rloU rhiU iloU ihiU) | strB* }
  331. ** knum   = intU0 | (loU1 hiU)
  332. ** ktab   = narrayU nhashU karray* khash*
  333. ** karray = ktabk
  334. ** khash  = ktabk ktabk
  335. ** ktabk  = ktabtypeU { intU | (loU hiU) | strB* }
  336. **
  337. ** B = 8 bit, H = 16 bit, W = 32 bit, U = ULEB128 of W, U0/U1 = ULEB128 of W+1
  338. */

  340. /* Bytecode dump header. */
  341. ‌#define BCDUMP_HEAD1        0x15
  342. ‌#define BCDUMP_HEAD2        0x22
  343. ‌#define BCDUMP_HEAD3        0x06

  345. /* If you perform *any* kind of private modifications to the bytecode itself
  346. ** or to the dump format, you *must* set BCDUMP_VERSION to 0x80 or higher.
  347. */
  348. ‌#define BCDUMP_VERSION        1

  350. /* Compatibility flags. */
  351. ‌#define BCDUMP_F_BE        0x01
  352. ‌#define BCDUMP_F_STRIP        0x02
  353. ‌#define BCDUMP_F_FFI        0x04

  355. ‌#define BCDUMP_F_KNOWN        (BCDUMP_F_FFI*2-1)

  357. /* Type codes for the GC constants of a prototype. Plus length for strings. */
  358. enum {
  359.     BCDUMP_KGC_CHILD, BCDUMP_KGC_TAB, BCDUMP_KGC_I64, BCDUMP_KGC_U64,
  360.     BCDUMP_KGC_COMPLEX, BCDUMP_KGC_STR
  361. };

  363. /* Type codes for the keys/values of a constant table. */
  364. enum {
  365.     BCDUMP_KTAB_NIL, BCDUMP_KTAB_FALSE, BCDUMP_KTAB_TRUE,
  366.     BCDUMP_KTAB_INT, BCDUMP_KTAB_NUM, BCDUMP_KTAB_STR
  367. };

  369. #endif /* __KTAP_BC_H__ */

One Level Up Top Level