ceph/src/civetweb/src/third_party/duktape-1.8.0/src-separate/duk_js_bytecode.h

   1 /*
   2  *  Ecmascript bytecode
   3  */
   4
   5 #ifndef DUK_JS_BYTECODE_H_INCLUDED
   6 #define DUK_JS_BYTECODE_H_INCLUDED
   7
   8 /*
   9  *  Logical instruction layout
  10  *  ==========================
  11  *
  12  *  !3!3!2!2!2!2!2!2!2!2!2!2!1!1!1!1!1!1!1!1!1!1! ! ! ! ! ! ! ! ! ! !
  13  *  !1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!
  14  *  +---------------------------------------------------+-----------+
  15  *  !       C         !       B         !      A        !    OP     !
  16  *  +---------------------------------------------------+-----------+
  17  *
  18  *  OP (6 bits):  opcode (DUK_OP_*), access should be fastest
  19  *  A (8 bits):   typically a target register number
  20  *  B (9 bits):   typically first source register/constant number
  21  *  C (9 bits):   typically second source register/constant number
  22  *
  23  *  Some instructions combine BC or ABC together for larger parameter values.
  24  *  Signed integers (e.g. jump offsets) are encoded as unsigned, with an opcode
  25  *  specific bias.  B and C may denote a register or a constant, see
  26  *  DUK_BC_ISREG() and DUK_BC_ISCONST().
  27  *
  28  *  Note: macro naming is a bit misleading, e.g. "ABC" in macro name but
  29  *  the field layout is logically "CBA".
  30  */
  31
  32 typedef duk_uint32_t duk_instr_t;
  33
  34 #define DUK_DEC_OP(x)               ((x) & 0x3fUL)
  35 #define DUK_DEC_A(x)                (((x) >> 6) & 0xffUL)
  36 #define DUK_DEC_B(x)                (((x) >> 14) & 0x1ffUL)
  37 #define DUK_DEC_C(x)                (((x) >> 23) & 0x1ffUL)
  38 #define DUK_DEC_BC(x)               (((x) >> 14) & 0x3ffffUL)
  39 #define DUK_DEC_ABC(x)              (((x) >> 6) & 0x3ffffffUL)
  40
  41 #define DUK_ENC_OP(op)              ((duk_instr_t) (op))
  42 #define DUK_ENC_OP_ABC(op,abc)      ((duk_instr_t) ( \
  43                                         (((duk_instr_t) (abc)) << 6) | \
  44                                         ((duk_instr_t) (op)) \
  45                                     ))
  46 #define DUK_ENC_OP_A_BC(op,a,bc)    ((duk_instr_t) ( \
  47                                         (((duk_instr_t) (bc)) << 14) | \
  48                                         (((duk_instr_t) (a)) << 6) | \
  49                                         ((duk_instr_t) (op)) \
  50                                     ))
  51 #define DUK_ENC_OP_A_B_C(op,a,b,c)  ((duk_instr_t) ( \
  52                                         (((duk_instr_t) (c)) << 23) | \
  53                                         (((duk_instr_t) (b)) << 14) | \
  54                                         (((duk_instr_t) (a)) << 6) | \
  55                                         ((duk_instr_t) (op)) \
  56                                     ))
  57 #define DUK_ENC_OP_A_B(op,a,b)      DUK_ENC_OP_A_B_C(op,a,b,0)
  58 #define DUK_ENC_OP_A(op,a)          DUK_ENC_OP_A_B_C(op,a,0,0)
  59
  60 /* Constants should be signed so that signed arithmetic involving them
  61  * won't cause values to be coerced accidentally to unsigned.
  62  */
  63 #define DUK_BC_OP_MIN               0
  64 #define DUK_BC_OP_MAX               0x3fL
  65 #define DUK_BC_A_MIN                0
  66 #define DUK_BC_A_MAX                0xffL
  67 #define DUK_BC_B_MIN                0
  68 #define DUK_BC_B_MAX                0x1ffL
  69 #define DUK_BC_C_MIN                0
  70 #define DUK_BC_C_MAX                0x1ffL
  71 #define DUK_BC_BC_MIN               0
  72 #define DUK_BC_BC_MAX               0x3ffffL
  73 #define DUK_BC_ABC_MIN              0
  74 #define DUK_BC_ABC_MAX              0x3ffffffL
  75 #define DUK_BC_EXTRAOP_MIN          DUK_BC_A_MIN
  76 #define DUK_BC_EXTRAOP_MAX          DUK_BC_A_MAX
  77
  78 #define DUK_OP_LDREG                0
  79 #define DUK_OP_STREG                1
  80 #define DUK_OP_LDCONST              2
  81 #define DUK_OP_LDINT                3
  82 #define DUK_OP_LDINTX               4
  83 #define DUK_OP_MPUTOBJ              5
  84 #define DUK_OP_MPUTOBJI             6
  85 #define DUK_OP_MPUTARR              7
  86 #define DUK_OP_MPUTARRI             8
  87 #define DUK_OP_NEW                  9
  88 #define DUK_OP_NEWI                 10
  89 #define DUK_OP_REGEXP               11
  90 #define DUK_OP_CSREG                12
  91 #define DUK_OP_CSREGI               13
  92 #define DUK_OP_GETVAR               14
  93 #define DUK_OP_PUTVAR               15
  94 #define DUK_OP_DECLVAR              16
  95 #define DUK_OP_DELVAR               17
  96 #define DUK_OP_CSVAR                18
  97 #define DUK_OP_CSVARI               19
  98 #define DUK_OP_CLOSURE              20
  99 #define DUK_OP_GETPROP              21
 100 #define DUK_OP_PUTPROP              22
 101 #define DUK_OP_DELPROP              23
 102 #define DUK_OP_CSPROP               24
 103 #define DUK_OP_CSPROPI              25
 104 #define DUK_OP_ADD                  26
 105 #define DUK_OP_SUB                  27
 106 #define DUK_OP_MUL                  28
 107 #define DUK_OP_DIV                  29
 108 #define DUK_OP_MOD                  30
 109 #define DUK_OP_BAND                 31
 110 #define DUK_OP_BOR                  32
 111 #define DUK_OP_BXOR                 33
 112 #define DUK_OP_BASL                 34
 113 #define DUK_OP_BLSR                 35
 114 #define DUK_OP_BASR                 36
 115 #define DUK_OP_EQ                   37
 116 #define DUK_OP_NEQ                  38
 117 #define DUK_OP_SEQ                  39
 118 #define DUK_OP_SNEQ                 40
 119 #define DUK_OP_GT                   41
 120 #define DUK_OP_GE                   42
 121 #define DUK_OP_LT                   43
 122 #define DUK_OP_LE                   44
 123 #define DUK_OP_IF                   45
 124 #define DUK_OP_JUMP                 46
 125 #define DUK_OP_RETURN               47
 126 #define DUK_OP_CALL                 48
 127 #define DUK_OP_CALLI                49
 128 #define DUK_OP_TRYCATCH             50
 129 #define DUK_OP_EXTRA                51
 130 #define DUK_OP_PREINCR              52  /* pre/post opcode values have constraints, */
 131 #define DUK_OP_PREDECR              53  /* see duk_js_executor.c */
 132 #define DUK_OP_POSTINCR             54
 133 #define DUK_OP_POSTDECR             55
 134 #define DUK_OP_PREINCV              56
 135 #define DUK_OP_PREDECV              57
 136 #define DUK_OP_POSTINCV             58
 137 #define DUK_OP_POSTDECV             59
 138 #define DUK_OP_PREINCP              60
 139 #define DUK_OP_PREDECP              61
 140 #define DUK_OP_POSTINCP             62
 141 #define DUK_OP_POSTDECP             63
 142 #define DUK_OP_NONE                 64  /* dummy value used as marker */
 143
 144 /* DUK_OP_EXTRA, sub-operation in A */
 145 #define DUK_EXTRAOP_NOP             0
 146 #define DUK_EXTRAOP_INVALID         1
 147 #define DUK_EXTRAOP_LDTHIS          2
 148 #define DUK_EXTRAOP_LDUNDEF         3
 149 #define DUK_EXTRAOP_LDNULL          4
 150 #define DUK_EXTRAOP_LDTRUE          5
 151 #define DUK_EXTRAOP_LDFALSE         6
 152 #define DUK_EXTRAOP_NEWOBJ          7
 153 #define DUK_EXTRAOP_NEWARR          8
 154 #define DUK_EXTRAOP_SETALEN         9
 155 #define DUK_EXTRAOP_TYPEOF          10
 156 #define DUK_EXTRAOP_TYPEOFID        11
 157 #define DUK_EXTRAOP_INITENUM        12
 158 #define DUK_EXTRAOP_NEXTENUM        13
 159 #define DUK_EXTRAOP_INITSET         14
 160 #define DUK_EXTRAOP_INITSETI        15
 161 #define DUK_EXTRAOP_INITGET         16
 162 #define DUK_EXTRAOP_INITGETI        17
 163 #define DUK_EXTRAOP_ENDTRY          18
 164 #define DUK_EXTRAOP_ENDCATCH        19
 165 #define DUK_EXTRAOP_ENDFIN          20
 166 #define DUK_EXTRAOP_THROW           21
 167 #define DUK_EXTRAOP_INVLHS          22
 168 #define DUK_EXTRAOP_UNM             23
 169 #define DUK_EXTRAOP_UNP             24
 170 #define DUK_EXTRAOP_DEBUGGER        25
 171 #define DUK_EXTRAOP_BREAK           26
 172 #define DUK_EXTRAOP_CONTINUE        27
 173 #define DUK_EXTRAOP_BNOT            28
 174 #define DUK_EXTRAOP_LNOT            29
 175 #define DUK_EXTRAOP_INSTOF          30
 176 #define DUK_EXTRAOP_IN              31
 177 #define DUK_EXTRAOP_LABEL           32
 178 #define DUK_EXTRAOP_ENDLABEL        33
 179
 180 /* DUK_OP_CALL flags in A */
 181 #define DUK_BC_CALL_FLAG_TAILCALL           (1 << 0)
 182 #define DUK_BC_CALL_FLAG_EVALCALL           (1 << 1)
 183
 184 /* DUK_OP_TRYCATCH flags in A */
 185 #define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH     (1 << 0)
 186 #define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY   (1 << 1)
 187 #define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING  (1 << 2)
 188 #define DUK_BC_TRYCATCH_FLAG_WITH_BINDING   (1 << 3)
 189
 190 /* DUK_OP_RETURN flags in A */
 191 #define DUK_BC_RETURN_FLAG_HAVE_RETVAL      (1 << 0)
 192
 193 /* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags (DUK_PROPDESC_FLAG_XXX) */
 194 #define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE     (1 << 4)  /* use 'undefined' for value automatically */
 195 #define DUK_BC_DECLVAR_FLAG_FUNC_DECL       (1 << 5)  /* function declaration */
 196
 197 /* misc constants and helper macros */
 198 #define DUK_BC_REGLIMIT             256  /* if B/C is >= this value, refers to a const */
 199 #define DUK_BC_ISREG(x)             ((x) < DUK_BC_REGLIMIT)
 200 #define DUK_BC_ISCONST(x)           ((x) >= DUK_BC_REGLIMIT)
 201 #define DUK_BC_LDINT_BIAS           (1L << 17)
 202 #define DUK_BC_LDINTX_SHIFT         18
 203 #define DUK_BC_JUMP_BIAS            (1L << 25)
 204
 205 #endif  /* DUK_JS_BYTECODE_H_INCLUDED */